Building a Server with Node.js and Express

Node.js is a JavaScript runtime environment that allows you to run JavaScript code outside of the browser. Traditionally, JavaScript was only used in browsers to make web pages interactive. However, with Node.js, you can write server-side applications in JavaScript.

Why use Node.js?
- Same Language Everywhere: You can use JavaScript for both front-end and back-end development, which makes learning easier.
- Non-blocking Architecture: Node.js handles multiple requests at the same time without waiting for each one to finish.
- Package Manager: Node.js comes with npm (Node Package Manager), which lets you easily install and manage libraries and tools.

Express.js is a web framework built on top of Node.js that makes it easier to write server applications. It provides helpful tools and methods that allow you to define routes, handle requests, and structure your server efficiently.

Before writing any code, you need to set up your environment. Follow these steps carefully.
Step 1 – Install Node.js
1. Download Node.js from the official website.
2. Follow the instructions to install Node.js for your operating system.
3. Verify the installation by opening your terminal or command prompt and typing: node -v
4. Also, check the version of npm by typing: npm -v
Step 2 – Create Your Project Folder
1. Create a folder named myserver or any name you like.
2. Open a terminal inside this folder.
3. Initialize the project by typing: npm init -y
Step 3 – Install Express.js

Now that the project is initialized, install Express by running: npm install express.

Step 4 – Create server.js
Inside your myserver folder, create a file named server.js. This will be the main file for your server.
Here’s the complete code:
// Import the express library
const express = require('express');
// Create an instance of express
const app = express();
// Define the port number
const port = 3000;
// Define a route for the home page
app.get('/', (req, res) => {
res.send('Hello! Welcome to my first server.');
});
// Start the server and listen on the defined port
app.listen(port, () => {
console.log(Server is running at http://localhost:${port});
});

What is a Route?
A route is an endpoint defined on the server that listens for specific requests. It usually consists of:
1. The URL path.
2. The HTTP method (GET, POST, etc.).
3. The handler function that processes the request and sends a response.

Let’s add more routes to see how the server can respond differently depending on the URL. Modify your server.js as follows:
const express = require('express');
const app = express();
const port = 3000;
// Home route
app.get('/', (req, res) => {
res.send('Hello! Welcome to my first server.');
});
// About route
app.get('/about', (req, res) => {
res.send('This is the About page.');
});
// Contact route
app.get('/contact', (req, res) => {
res.send('You can contact us at contact@example.com.');
});
app.listen(port, () => {
console.log(Server is running at http://localhost:${port});
});

Sometimes you want the server to respond differently depending on the data in the request. Express allows you to define parameters in the URL. Example: Greeting by Name
Add this route:
app.get('/greet/:name', (req, res) => {
const userName = req.params.name;
res.send(Hello, ${userName}! Welcome to the server.);
});

You can also pass data through query strings like this: http://localhost:3000/search?term=nodejs
Example: Searching by Query Parameter
Add this route:
app.get('/search', (req, res) => {
const searchTerm = req.query.term;
res.send(You searched for: ${searchTerm});
});

So far, we've only sent plain text as responses. Servers can also send HTML content, which browsers render as webpages. Example: Serving HTML
app.get('/html', (req, res) => {
res.send(`

Welcome to the HTML page!

This page is being served by Express.js.

`);
});

Middleware functions are functions that run between the request and response. They can modify the request, handle errors, or perform other tasks. Example: Simple Logging Middleware
app.use((req, res, next) => {
console.log(${req.method} request for ${req.url});
next(); // Pass control to the next handler
});

You can serve static files like images, stylesheets, and JavaScript files using Express. Example: Serving Static Files
1. Create a folder named public in your project directory.
2. Add a file style.css in public:
3. In server.js, add this line before defining routes:
app.use(express.static('public'));

So far, we've only handled GET requests where the browser fetches data. POST requests are used when sending data to the server. Example: Handling Form Data
1. Create a route to display the form:
app.get('/form', (req, res) => {
res.send(<form action="/submit" method="POST"> <input type="text" name="username" placeholder="Enter your name" required> <button type="submit">Submit</button> </form>);
});
2. Install the middleware to parse form data:
app.use(express.urlencoded({ extended: true }));
3. Handle the form submission:
app.post('/submit', (req, res) => {
const username = req.body.username;
res.send(Form submitted! Hello, ${username}.);
});

In Express, each route handler receives two important objects:
- req (short for request): Contains all the information about the client's request, including parameters, query strings, body data, headers, etc.
- res (short for response): Contains methods to send a response back to the client.

While this chapter focuses on simple examples, you should be aware that real-world servers are structured more carefully. Best practices include:
1. Separate routes into different files.
2. Use middleware for common tasks like parsing requests.
3. Use environment variables for configuration like port numbers.
4. Handle errors gracefully using error-handling middleware.