10 Express Routing Best Practices

Express is a web application framework for Node.js that provides a range of features to help you create web and mobile applications. Express routing is a critical component of Express and is used to define the endpoints for an Express application.

In this article, we will discuss 10 best practices for Express routing. By following these best practices, you can improve the performance and maintainability of your Express applications.

1. Keep your routes short

Long routes are hard to maintain, and if you ever need to make a change, you’ll have to update every single route that uses that path. For example, let’s say you have a route like this:

app.get(‘/users/:id’, function(req, res) {
// …
});
And then you decide you want to add a query parameter, so you update the route to this:

app.get(‘/users/:id’, function(req, res) {
// …
});
Now imagine you have 100 routes that use the /users/:id path. You would have to go through and update all 100 of those routes.

It’s much easier to maintain shorter routes, so it’s best to keep your routes as short as possible.

2. Use middleware to handle errors and validate data

Middleware is a function that has access to the request and response objects, and it can also be used to modify data before it’s sent to the client. This makes middleware the perfect tool for handling errors, because you can use it to intercept requests and prevent them from reaching the controller if there are any errors.

You can also use middleware to validate data before it’s passed to the controller. This is important because it ensures that the data is in the correct format and that all required fields are present. By validating data before it reaches the controller, you can avoid having to write duplicate code in the controller to handle these checks.

3. Avoid using app.use() for anything other than application-level middleware

When you use app.use(), it will apply the middleware to every single route in your express application. This can lead to issues where certain routes are not working as intended because they are being affected by middleware that is not relevant to them.

It is always better to be specific when applying middleware, and this means using router-level middleware rather than app-level middleware wherever possible. Router-level middleware will only apply the middleware to the routes that are using that particular router, which avoids any potential conflicts.

4. Don’t use arrow functions in route handlers

When an arrow function is used in a route handler, the value of this is lexically bound to the module.exports object. This means that if you try to access req, res, or next within the arrow function, they will be undefined.

Instead, use a regular function declaration for your route handlers. This will ensure that the value of this is set to the request object, and you’ll be able to access req, res, and next as expected.

5. Use plural nouns for resources

When you use a plural noun for a resource, it’s easier to map the routes to the corresponding controller actions. For example, if you have a route for “/articles”, it’s easy to map that to an ArticlesController with an index action.

It’s also more consistent with the RESTful conventions. When you use a plural noun, it indicates that the route represents a collection of resources.

6. Use the appropriate HTTP method

The different HTTP methods were designed for different purposes, and using the wrong method can cause problems. For example, the GET method is used to retrieve data, while the POST method is used to create data. If you use the GET method to try to create data, it will probably fail, because that’s not what it’s designed to do.

Similarly, the PUT method is used to update data, while the DELETE method is used to delete data. If you use the PUT method to try to delete data, it will probably fail, because that’s not what it’s designed to do.

So, when you’re designing your express routes, make sure you’re using the appropriate HTTP method for the action you want to perform.

7. Use a descriptive name for each route

When you’re building an API or website, there are going to be a lot of routes. If each route has a generic name like “/api/v1/get-user” it’s going to be very difficult to keep track of what each route does.

It’s much better to use a descriptive name that tells you exactly what the route does. For example, a route that gets a user’s profile could be named “/api/v1/get-user-profile”.

Not only is this easier to understand, but it also makes your code more readable and maintainable.

8. Use query parameters for optional filters

Query parameters allow for more flexibility when it comes to filtering the data that is returned from an API endpoint. For example, let’s say you have an endpoint that returns a list of users. With query parameters, you could add a filter to only return users that are active, or that have a certain role, etc.

Without query parameters, you would need to create a separate endpoint for each different type of filter. This can quickly become unmanageable, especially if you have a lot of different filters that could be applied.

Query parameters also have the advantage of being able to be changed on the fly. So, if you need to change the filter that is being applied, you can do so without having to deploy a new version of your API.

9. Use nested routers when grouping routes by resource

If you have a set of routes that all relate to the same resource, for example, a set of routes for managing users, it’s best to group those routes together using a nested router. By doing so, you can avoid having to repeat the portion of the path that corresponds to the resource in each individual route.

For instance, let’s say you have the following routes:

/users/new
/users/:id
/users/:id/edit

Instead of defining each route individually, you could use a nested router and define them as follows:

/users/new
/users/:id
/users/:id/edit

Doing so would make your code more concise and easier to read and maintain.

10. Use subdomains for versioning

When you’re building an API that will be used by other developers, it’s important to version it from the start. This way, as you make breaking changes in future versions, those changes won’t affect existing users of your API.

One way to do this is to use subdomains for each version of your API. For example, if your current API is at api.example.com, you could create a new version at v2.api.example.com. Then, when you make breaking changes to your API, you can update the v2 subdomain and leave the original api.example.com intact.

This approach has a few benefits. First, it’s easy to implement. You can simply route all requests to the appropriate subdomain using a wildcard DNS entry. Second, it’s easy to understand. When someone sees a request to v2.api.example.com, they’ll know immediately that it’s a different version of the API than api.example.com.

Finally, it’s easy to change. If you decide you want to change the structure of your subdomains (for example, from v2 to 2.0), you can do so without affecting any existing users.