Error handling is a crucial aspect of building robust and reliable web applications in Express. It’s all about managing unexpected issues that might arise during the execution of your code. Let’s break down the concepts in detail and provide easy-to-understand explanations.

Catching Synchronous Errors:

When you’re dealing with synchronous code (code that executes in a predictable order), Express can automatically catch and process errors that occur. For instance:

app.get('/', (req, res) => {
throw new Error('Something went wrong'); // Express will catch this on its own.
});

In this case, if an error is thrown, Express will catch it and handle it appropriately. You don’t need to do anything special.

Catching Asynchronous Errors:

However, when you’re dealing with asynchronous code (code that involves callbacks, promises, or async/await), you need to handle errors a bit differently. Express won’t automatically catch these errors, so you need to make sure they are passed to Express for proper handling. Here’s how:

app.get('/', (req, res, next) => {
  fs.readFile('/file-does-not-exist', (err, data) => {
    if (err) {
      next(err); // Pass errors to Express.
    } else {
      res.send(data);
    }
  });
});

In this example, if the fs.readFile operation encounters an error, you pass that error to Express using the next function. This tells Express to handle the error using its error-handling mechanisms.

Using Promises for Error Handling:

Starting from Express 5, if a route handler or middleware that returns a Promise rejects or throws an error, Express will automatically pass that error to the next function. For example:

app.get('/user/:id', async (req, res, next) => {
  const user = await getUserById(req.params.id);
  res.send(user);
});

In this example, if getUserById throws an error or rejects the Promise, Express will automatically catch the error and pass it to the next function.

Providing a Custom Error Handler:

To handle errors globally, you can define a custom error handler middleware after your routes and other middleware. This middleware has four parameters: (err, req, res, next).

app.use((err, req, res, next) => {
  console.error(err.stack); // Log the error
  res.status(500).send('Something went wrong!'); // Send an error response
});

This middleware will be triggered whenever an error is passed to next.

The key takeaway is that you must ensure any error that occurs within your route handlers or middleware (synchronous or asynchronous) is either caught and passed to next or handled within your route handler.

Remember that effective error handling improves the user experience and helps you identify and address issues in your application more efficiently.

Organizing Error Handlers:

You can define multiple error-handling middleware functions for different purposes. For instance, you might have a general error logger and a specific client error handler:

app.use(logErrors);
app.use(clientErrorHandler);
app.use(errorHandler);

These handlers are organized in the same way as regular middleware. For example, logErrors might log errors to the console, clientErrorHandler handles errors for XHR requests, and errorHandler renders an error page.

Skipping Route Handlers:

If you want to skip a specific route handler based on certain conditions, you can use the next('route') mechanism:

app.get('/a_route',
  (req, res, next) => {
    if (!req.user.hasPaid) {
      next('route'); // Skip this route handler
    } else {
      next(); // Proceed to the next handler
    }
  },
  (req, res) => {
    // This handler will be skipped for unpaid users
  });

In this example, the second handler will be skipped if the condition isn’t met.

Remember, error handling ensures that your application gracefully handles unexpected issues and provides a better user experience. Properly handling errors prevents crashes and helps you troubleshoot problems effectively.