Routing in Express.js

Introduction

Express.js is a popular web framework for Node.js that provides a robust set of features for building web applications. One of the key features of Express.js is its routing system, which allows developers to define how their application responds to different types of requests. In this article, we’ll explore the routing system in Express.js and provide tips and best practices for building efficient and scalable web applications.

Route methods

Route methods correspond to HTTP methods like GET, POST, PUT, and DELETE. When a client makes a request to your application, the server checks the method used in the request and maps it to the corresponding route method in your code. You can use the route methods to handle requests of different types and specify how your application responds to them.

For example, to handle a GET request to the root path, you can use the get() method as follows:

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

Similarly, to handle a POST request to the ‘/login’ path, you can use the post() method:

app.post('/login', (req, res) => {
  // Handle login request here
});

Route paths

Route paths are used to specify the URL pattern that your application should match. You can use placeholders or parameters in route paths to capture dynamic values from the URL.

For example, to handle a request for the ‘/users’ path with a dynamic user ID parameter, you can define a route like this:

app.get('/users/:id', (req, res) => {
  const userId = req.params.id;
  // Handle user ID request here
});

In this example, the :id placeholder captures the user ID value from the URL and stores it in the params object of the request object req. You can access this value in your code using the req.params.id property.

You can also use regular expressions to define route paths and match URLs with specific patterns. For example, to match any URL that starts with ‘/ab’ followed by zero or more characters, you can use the following route definition:

app.get(/^\/ab(.*)/, (req, res) => {
  // Handle matching URL request here
});

Route parameters

Route parameters are used to capture dynamic values from the URL. You can use route parameters to make your routes more flexible and allow your application to respond to a wider range of requests.

For example, to handle a request for the ‘/products’ path with dynamic product and category IDs, you can define a route like this:

app.get('/products/:productId/category/:categoryId', (req, res) => {
  const productId = req.params.productId;
  const categoryId = req.params.categoryId;
  // Handle product and category IDs request here
});

In this example, the route path contains two route parameters :productId and :categoryId that capture the corresponding values from the URL.

Route handlers

Route handlers are functions that handle requests to your application’s routes. You can use route handlers to perform specific actions or send specific responses based on the requests.

For example, to handle a GET request to the ‘/users’ path and send a JSON response, you can define a route like this:

app.get('/users', (req, res) => {
  const users = [
    { id: 1, name: 'John' },
    { id: 2, name: 'Jane' },
    { id: 3, name: 'Mark' }
  ];
  res.json(users);
});

In this example, the get() method is used to define a route that handles a GET request to the ‘/users’ path. The route handler function sends a JSON response with an array of user objects.

You can also chain multiple route handlers together for a single route. This can be useful for handling middleware functions that execute before or after the main route handler.

For example, to handle a GET request to the ‘/admin’ path and check if the user is authenticated before sending a response, you can define a route like this:

app.get('/admin', isAuthenticated, (req, res) => {
  // Handle authenticated user request here
});

function isAuthenticated(req, res, next) {
  // Check if user is authenticated here
  // Call next() to continue to the next handler
  next();
}

In this example, the isAuthenticated() middleware function is executed before the main route handler. If the user is authenticated, the function calls next() to continue to the route handler. If the user is not authenticated, the middleware function can send an error response or redirect the user to a login page.

Conclusion

The routing system in Express.js is a powerful feature that allows developers to define how their application responds to different types of requests. By using route methods, route paths, route parameters, and route handlers, you can build efficient and scalable web applications that can handle a wide range of requests. In this article, we’ve covered the basics of routing in Express.js and provided some tips and best practices for building robust web applications. With this knowledge, you can take your Express.js development skills to the next level and build powerful web applications that meet your users’ needs.