Explain Error Handling in Express.js Using An Example

Error Handling is one of the most important parts of any web application development process. It ensures that when something goes wrong in your application, the error is caught, processed, and appropriately communicated to the user without causing the app to crash. In Express.js error handling, requires a proper understanding of how middleware and error-handling mechanisms work.

What is Error Handling in Express.js?

Error Handling in Express.js involves capturing and managing errors that occur during the processing of HTTP requests. This may involve validation errors, runtime errors, database connection issues, or other unexpected exceptions. Without proper error handling, these errors can lead to unhandled rejections, server crashes, or poor user experiences.

Express uses a middleware approach to handle errors, allowing you to define functions that catch and respond to errors throughout your application.

How Error Handling Works in Express.js?

Express.js handles errors through middleware functions, specifically error-handling middleware. A middleware in Express is a function that takes in a request (req), response (res), and the next function (next). In the case of error-handling middleware, it also takes in an additional err argument, making it look like this:

function errorHandler(err, req, res, next) {
    // Handle the error
}

For Express to recognize a middleware as an error handler, it must have four parameters: err, req, res, and next. This middleware can be placed at any point in the request-response cycle but is often placed after route definitions to catch errors generated during request processing.

Reason For Using Error Handling in Express.js

• To prevent application crashes: Without error handling, unhandled errors can cause an application to crash, leading to poor user experience and potential data loss. Error handling allows you to capture and respond to errors, preventing them from causing a crash and keeping the application running smoothly.
• To provide meaningful error messages: Error handling allows you to provide meaningful and user-friendly error messages to your users, rather than leaving them with a blank screen or a default error message. This can help to improve the overall user experience and prevent confusion or frustration.
• To improve debugging: Error handling allows you to capture and log errors, making it easier to debug your application and identify the root cause of any issues. This can save time and effort when troubleshooting problems with your application.
• To comply with standards and regulations: Proper error handling is often a requirement for compliance with security standards and regulations. By handling errors correctly, you can ensure that your application meets these standards and regulations.

Ways to Perform Error Handling

1. Middleware function

Express.js has built-in support for error-handling middleware, which allows you to handle errors that occur during the execution of the application.

Syntax:

app.use(function(error, request, response, next) {
    // Handle the error
    response.status(500).send('Internal Server Error');
});

2. Try-Catch statements

You can use try-catch statements to handle errors that occur within specific blocks of code. This ensures that any errors that occur are caught and handled in a controlled manner.

Syntax:

app.get('/', function (req, res) {
    try {
        // Code that might throw an error
    } catch (error) {
        // Handle the error
        res.status(500).send('Internal Server Error');
    }
});

3. Error logging

You can set up error logging so that any errors that occur during the execution of the application are logged to a file or a database for later analysis.

Syntax:

app.get('/', function (req, res) {
    try {
        throw new Error('Something went wrong');
    } catch (error) {
          console.error(error);
    }
});

Error codes: You can set up error codes for different types of errors that occur during the execution of the application. This makes it easier to identify and handle specific errors.

• Error codes in Node.js are symbolic values that represent specific types of errors that can occur during the execution of a program.
• For example, the Node.js fs module uses error codes such as 'ENOENT' (no such file or directory) or 'EACCES' (permission denied) to represent specific types of file system errors.
• When an error occurs in your Node.js application, you can access the error code by checking the code property of the error object.

Example:

const fs = require('fs');

fs.readFile('nonexistent-file.txt', (error, data) => {
    if (error) {
        console.error(error.code);
    } else {
        console.log(data.toString());
    }
});

4. HTTP status codes

You can use HTTP status codes to indicate the type of error that occurred. For example, a status code of 400 (Bad Request) can indicate a validation error, while a status code of 500 (Internal Server Error) can indicate a server-side error.

Syntax:

 const http = require('http');

const server = http.createServer((request, response) => {
    response.statusCode = 200;
    response.end('OK');
});

server.listen(8080);

• By using any of the above, you can handle errors in a controlled and efficient manner, and ensure that your application is robust and stable.

Let's see some basic examples and explanations for Error Handling in Express.js:

Example 1: Using a middleware function: You can use a middleware function to handle errors that occur during the execution of an application. The middleware function should have four arguments: error, request, response, and next.

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

// Custom error handling middleware
const errorHandler = (err, req, res, next) => {
    console.error(err.stack);
    res.status(500).send('Something went wrong!');
};

app.use((req, res, next) => {
    throw new Error('Something broke!');
});

// Use the custom error handling middleware
app.use(errorHandler);

app.listen(3000, () => {
    console.log('App is listening on port 3000');
});

Steps to run the application: Write the below code in the terminal to run the application:

node index.js

Output: 

Explanation: 

• In this example, we define a custom error-handling middleware function errorhandler that logs the error stack and sends a response with a status code of 500 and the message "Something went wrong!".
• We then use the custom error handling middleware by adding the app.use(errorhandler) after defining it.
• This error-handling middleware will catch any errors thrown in the previous middleware or routes, and handle them according to the logic defined in the errorHandler function.
• The first line App is listening on port 3000 is logged when the Express app starts listening on port 3000.
• If you make a request to the app, the custom middleware will throw an error, which will then be caught by the error-handling middleware. The error stack trace will be logged to the console, and the response sent to the client will have a status code of 500 and the message "Something went wrong!".

Example 2: Using the try-catch statement: You can use the try-catch statement to handle errors that occur within a specific block of code.

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

app.get('/', (req, res, next) => {
    try {
        // Some code that might throw an error
        const data = someFunctionThatMightThrowError();
        res.status(200).json(
            { message: 'Data retrieved successfully', data });
    } catch (error) {
        next(error);
    }
});

// Custom error handling middleware
app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).json(
        { message: 'Something went wrong!' });
});

app.listen(3000, () => {
    console.log('App is listening on port 3000');
});

Explanation:

• In this example, we wrap the code that might throw an error in a try block. If an error is thrown, it will be caught by the corresponding catch block, which logs the error stack and sends a response with a status code of 500 and the message "Something went wrong!".
• This approach allows for more fine-grained error handling, as the try-catch statement can be used multiple times in different middleware functions or routes.

Steps to run the application: Write the below code in the terminal to run the application:

node index.js

Output:

Explanation:

• If you make a request to the app, the custom middleware will throw an error, which will then be caught by the try-catch statement. The error stack trace will be logged to the console, and the response sent to the client will have a status code of 500 and the message "Something went wrong!".
• Note that the [ERROR STACK TRACE] part of the output will vary depending on the exact error that was thrown. It will contain details about the error, such as the error message and the location in the code where the error was thrown.
• his output will be displayed if you make a request to the app and an error is thrown by the custom middleware. The error stack trace will be logged to the console and the response sent to the client will have a status code of 500 and the message "Something went wrong!".
• This output will be displayed when the Express app starts listening on port 3000. No error will be thrown if you do not make any requests to the app.

Example 3: Using the next() function: You can use the next() function to pass errors to the next middleware function in the chain.

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

app.get('/', (req, res, next) => {
    // Some code that might throw an error
    const data = someFunctionThatMightThrowError();
    if (!data) {
        return next(new Error('Error retrieving data'));
    }
    res.status(200).json(
        { message: 'Data retrieved successfully', data });
});

// Custom error handling middleware
app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).json(
        { message: 'Something went wrong!' });
});

app.listen(3000, () => {
    console.log('App is listening on port 3000');
});

Explanation: 

• In this example, we have two middleware functions. The first middleware function throws an error, and the second middleware function is used for error handling. If an error is thrown in the first middleware function, the control flow is passed to the second middleware function using the next() function. The error is then logged to the console and a response with a status code of 500 and the message "Something went wrong!" is sent to the client.
• This approach allows for error handling to be handled separately from the middleware functions that perform the core functionality of the application.

Steps to run the application: Write the below code in the terminal to run the application:

node index.js

Here's an example using curl:

• Open a terminal or command prompt.
• Navigate to the directory where the program is located.
• Start the application by running node app.js.
• In another terminal window, run the following command to make a request to the '/' endpoint:

curl http://localhost:3000

Output:

• If you make a request to the app, the first middleware function will throw an error. The error will be passed to the second middleware function using the next() function, where it will be logged to the console and a response with a status code of 500 and the message "Something went wrong!" will be sent to the client.
• Note that the [ERROR STACK TRACE] part of the output will vary depending on the exact error that was thrown. It will contain details about the error, such as the error message and the location in the code where the error was thrown.