How can you handle routing in an Express.js application?

The basic steps for handling routing in an Express.js application consist of several key parts. I will explain them step by step, providing corresponding code examples.

Step 1: Importing the Express Module and Creating an Application Instance

First, we import the Express module and create an application instance. This is the foundation of any Express application.

javascript
const express = require('express');
const app = express();

Step 2: Defining Routes

Next, we define the application's routes. Routing involves the paths and HTTP methods that an application uses to respond to client requests. In Express, we can define routes for various HTTP methods using methods such as app.get(), app.post(), app.put(), and app.delete().

For example, suppose we want to add routes for a simple blog system:

javascript
// Retrieve all blog posts
app.get('/posts', (req, res) => {
    res.send('Retrieving post list');
});

// Retrieve a single blog post
app.get('/posts/:id', (req, res) => {
    res.send(`Retrieving post with ID ${req.params.id}`);
});

// Create a new blog post
app.post('/posts', (req, res) => {
    res.send('Creating new post');
});

// Update a blog post
app.put('/posts/:id', (req, res) => {
    res.send(`Updating post with ID ${req.params.id}`);
});

// Delete a blog post
app.delete('/posts/:id', (req, res) => {
    res.send(`Deleting post with ID ${req.params.id}`);
});

Step 3: Using Middleware

In Express, we can also use middleware to handle requests and enhance routing functionality. Middleware functions can execute code, modify request and response objects, terminate the request-response cycle, or pass control to the next middleware in the stack.

For instance, if we want to add a simple logging feature to all requests, we can do the following:

javascript
app.use((req, res, next) => {
    console.log(`Request type: ${req.method}, Request URL: ${req.url}`);
    next();
});

Step 4: Grouping and Modularizing Routes

As the application grows, routes can become complex. To manage this complexity, we can group and modularize routes. Express allows us to use express.Router to create modular route handlers.

For example, we can place all blog post-related routes in a separate file:

javascript
// In posts.js file
const express = require('express');
const router = express.Router();

router.get('/', (req, res) => {
    res.send('Retrieving post list');
});

router.get('/:id', (req, res) => {
    res.send(`Retrieving post with ID ${req.params.id}`);
});

// Export the router
module.exports = router;

Then, in the main application file, we reference this route module:

javascript
const postsRouter = require('./routes/posts');
app.use('/posts', postsRouter);

Step 5: Listening on a Port to Start the Application

Finally, we need to have the application listen on a port to accept incoming requests:

javascript
const PORT = 3000;
app.listen(PORT, () => {
    console.log(`Server running at http://localhost:${PORT}`);
});

By following these steps, we can effectively handle routing in Express.js applications while maintaining code organization and maintainability.