Error handling in Node.js applications

Reading Time: 3 minutes

Error handling in applications is a very important part of the development process. It is important to handle errors in a way that is easy to understand and debug. This is especially true when developing applications that are used by other developers. Throughout this article we will see how we can handle errors in Node JS applications.

Error Handling in Node.js

When working in an application environment like node, it is important to understand how errors are handled. Node is a single-threaded environment, meaning that all of the code that is executed in the application is executed in a single thread. This means that if an error occurs in one part of the application, it will affect the entire application. This is why it is important to handle errors in an easy way.

Even though node is a single-threaded environment, it is still possible to have multiple threads running at the same time. In other words, if an error occurs in one part of the application, it will affect the entire application, and if it is not handled properly, this can cause the application to crash leaving other requests waiting for a response, or even worse, in an incorrect state.

Let’s take a look at a simple example of how to handle errors in Node JS applications. We will be using the express framework to create a simple web server. We will then use the express framework to create a simple web server that will handle errors in a way that is easy to understand and debug.

The first thing we need to do is create a simple web server.

Basic Node.js Application

const express = require('express');
const app = express();
app.get('/', (req, res) => {
    res.send('Hello World!');
});
app.listen(3000, () => console.log('Example app listening on port 3000!'));

Now let’s assume that the get request to the root of the application fails. We could handle this error by using the express framework to create a simple web server.

Bad Error Handling

const express = require('express');
const app = express();
app.get('/', (req, res) => {
    res.badSend('Hello World!');
});
app.listen(3000, () => console.log('Example app listening on port 3000!'));

In this example, the error is not detected, therefore the application will crash. This is because the badSend function does not exist. if there are other requests waiting for a response, they will also be affected by this error.

Handling The Error

const express = require('express');
const app = express();
app.get('/', (req, res) => {
    try {
        res.badSend('Hello World!');
    } catch (err) {
        console.log(err);
        res.status(500).send('Something broke!');
    }
});
app.listen(3000, () => console.log('Example app listening on port 3000!'));

This is a very simple way to protect the code from crashing. However, this is not the best way to handle errors in Node JS applications. The reason for this is that the error may occur in a different part of the application.

Using Middleware

A better way to handle errors in Node JS applications is to use a middleware. Middleware is a function that is called before the request is processed. Middleware can be used to handle errors in a way that is easy to understand and debug.

const express = require('express');
const app = express();
app.use((req, res, next) => {
    try {
        next();
    } catch (err) {
        console.log(err);
        res.status(500).send('Something broke!');
    }
});
app.get('/', (req, res) => {
    res.badSend('Hello World!');
});
app.listen(3000, () => console.log('Example app listening on port 3000!'));

This is way better, however it also assumes that the error will occur in the middleware. This is not always the case. The error may occur in a different part of the application.
This means that the error may not be handled properly and the application may crash.

Testing an Error Outside The Main Get Request Using Middleware

A better way to handle errors in Node JS applications is to use a Middleware. Middleware is a function that is called before the request is processed. Middleware can be used to handle errors in a way that is easy to understand and debug.

const express = require('express');
const app = express();
app.use((req, res, next) => {
    try {
        next();
    } catch (err) {
        console.log(err);
        res.status(500).send('Something broke!');
    }
});
app.get('/', (req, res) => {
    setTimeout(() => {
        throw new Error('Something bad happened');
    }, 1000);
    res.send('Hello World!');
});
app.listen(3000, () => console.log('Example app listening on port 3000!'));

Global Error Handler

const express = require('express');
const app = express();
process.on('uncaughtException', (err) => {
    console.log(err);
});

app.use((req, res, next) => {
    try {
        next();
    } catch (err) {
        console.log(err);
        res.status(500).send('Something broke!');
    }
});
app.get('/', (req, res) => {
    setTimeout(() => {
        throw new Error('Something bad happened');
    }, 1000);
    res.send('Hello World!');
});
app.listen(3000, () => console.log('Example app listening on port 3000!'));

There are some more advanced ways to handle errors in Node JS applications. These are not covered in this article. If you are interested in learning more about error handling in Node JS applications, you can check out the following resources:

0 Shares:
You May Also Like
Read More

An introduction to Rust

Reading Time: 4 minutes At MagmaLabs we always keep up to date by trying and using new technologies because of our client's…