Expressjs Routing And Middleware Complete Guide

Top 10 Questions and Answers on Express.js Routing and Middleware

1. What is Express.js routing?

2. How do you create a basic route in Express.js?

Answer: Creating a basic route in Express involves defining a method on the Express app object or router that specifies the URL pattern and the handler function to execute when the request matches the pattern and method. Here’s a simple example:

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

app.get('/', (req, res) => {
    res.send('Hello World!');
});

app.listen(3000);

In this example, app.get() creates a route that responds with 'Hello World!' when a GET request is made to the root URL (/).

3. Can routes be defined using regular expressions?

Answer: Yes, routes in Express can also be defined using regular expressions. This allows for more flexible URL patterns, useful when you need to handle dynamic segments or other complex path structures. For example:

app.get(/^\/hello\/(\w+)$/, (req, res) => {
    const name = req.params[0];
    res.send(`Hello ${name}!`);
});

This route matches any URL that starts with /hello/ followed by a word character sequence and captures it into req.params[0].

4. What is Middleware in Express.js?

Answer: Middleware in Express.js are functions that have access to the request object (req), the response object (res), and the next middleware function in the application’s request-response cycle. These functions can execute any code, make changes to the request and the response objects, end the request-response cycle, and call the next middleware function in the stack. Middleware are key components for building web applications as they help with tasks such as parsing bodies, setting headers, logging requests, authentication, error handling, and much more.

5. How do you use custom middleware in Express.js?

Answer: To add a custom middleware in Express, simply define a function that takes in the request (req), response (res), and next callback parameters, then register it using app.use() or directly in the route:

function myMiddleware(req, res, next) {
    console.log('Request received');
    next(); // Call next to pass control to the next middleware function
}

app.use(myMiddleware);

// Or in a specific route
app.get('/', myMiddleware, (req, res) => {
    res.send('Hello World!');
});

6. What are some built-in middlewares provided by Express.js?

Answer: Express has several built-in middleware modules:

• express.json(): Parses JSON bodies.
• express.urlencoded(): Parses URL-encoded bodies (key-value pairs), often used when submitting forms.
• express.static(): Serves static files from a specified directory.
• express.Router(): Facilitates route modularization.

Example:

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

app.use(express.json()); // For parsing JSON bodies
app.use(express.static('public')); // Serve static files from 'public' dir

7. How do you chain multiple middleware functions in a route in Express.js?

Answer: In Express, you can chain multiple middleware functions in a single route by passing them as arguments before the final handler function. Middleware functions must call next() to pass control to the next middleware in the chain.

function checkAuth(req, res, next) {
    if (req.isAuthenticated()) return next();
    res.status(403).send('Access Denied');
}

function logRequest(req, res, next) {
    console.log('Request logged');
    next();
}

app.get('/profile', checkAuth, logRequest, (req, res) => {
    res.send('Profile Page');
});

Here, checkAuth first checks if the user is authenticated, and if so, calls logRequest, which logs the request and passes control to the final route handler.

8. What are third-party middlewares, and how do you use them?

Answer: Third-party middlewares are modules created by the community that you install via npm and integrate into your Express app to add specific functionalities like database connection management (mongoose), cookie parsing (cookie-parser), error handling (helmet), etc. Here’s an example of using body-parser for parsing JSON requests:

npm install body-parser

Then in your app:

const bodyParser = require('body-parser');

app.use(bodyParser.json());

However, note that starting from Express 4.16, you don’t need body-parser anymore as most of its features were incorporated into Express itself.

9. How does the Error Handling Middleware work in Express.js?

Answer: Error-handling middleware follow the same signature as the other middlewares except they take four arguments instead of three, specifically (err, req, res, next). They can catch errors thrown in any synchronous or asynchronous middleware or route handlers, allowing for centralized error management. Example:

function errorHandler(err, req, res, next) {
    console.error(err.stack);
    res.status(500).send('Something broke!');
}

app.use(errorHandler);

You can throw errors using next(new Error(...)) anywhere in your route handlers or middleware to trigger the error handler.

10. Can you explain the purpose of the next function in middleware?

Answer: The next parameter in middleware functions is a callback function that tells Express to move to the next middleware function. If next() is called without any arguments, the remaining middleware functions will be executed in order based on the stack position. However, next(err) triggers the error handling middleware, bypassing all other remaining non-error handling middleware.

In summary, next() serves as a controller for the flow of middleware execution, allowing developers to perform tasks sequentially or jump directly to an error handler.