Node.js Debugger

The Node.js Debugger is used to identify and troubleshoot errors. It helps developers pause program execution, inspect variables, set breakpoints and execute code step by step to understand how the program is working.

What is a Node.js Debugger

The Node.js debugger is a built-in debugging capability. It allows us to inspect, pause and step through our JavaScript code line by line during runtime to identify and fix errors.  Node.js provides various built-in tools to help troubleshoot and debug applications.

Why Use Node.js Debugger

We can use the Node.js debugger in the following cases:

Error detection: The Node.js debugger is helpful for developers to identify and troubleshoot errors. It allows them to stop execution, inspect variables and analyze the state of the program while it is running.

Inspect Variables: It permits us to check the values of variables while the program is running.

Set breakpoints: We can pause execution at specific lines of code to inspect the program's behavior and analyze program flow.

Track program execution: We can follow the code step by step to understand how the program executes and how each statement is executed.

Debug asynchronous operations: It assists developers identify and troubleshoot issues in callbacks, Promises and async/await operations.

Common Node.js Debugger Options

The commonly used Node.js debugging options are given below:

Using --inspect in Node.js

The --inspect flag activates the V8 inspector in Node.js that lets us to debug our server-side JavaScript code using debugging tools such as Chrome DevTools or Visual Studio Code. The Node.js Inspector listens on 127.0.0.1:9229 by default.

Code:

const http = require ("http");

const server = http.createServer((req, res) => {
    const message = "Hello, Node.js!" ;
    console.log(message);
    res.end(message);
});

server.listen(3000, () => {
       console.log("Server running on port 3000");
 });

Save the code as app.js and run it with:

node --inspect app.js

Output:

Debugger listening on ws://127.0.0.1:9229…
Server running on port 3000

Explanation:

The --inspect flag starts the Node.js Inspector on the default debugging address 127.0.0.1:9229. We can then connect a debugging client such as Chrome DevTools to inspect the running application, set breakpoints and examine variables.

Using --inspect-brk

The --inspect-brk flag starts the debugger and pauses execution before the user code begins executing. It permits developers to attach a debugger before any application code is executed.

Syntax

node --inspect-brk app.js

Code:

function calculateTotal(price, tax) {
        const subtotal = price * 2;
        const total = subtotal + tax;
        return total;
}
console.log(calculateTotal(100, 5));

Output:

205

Explanation:

In the above example, we have defined a function called calculateTotal() that doubles the given price, adds the tax to it and returns the total value which is then displayed in the console as 205.

Debugging Node.js with Chrome DevTools and VS Code

We can debug Node.js applications using tools such as Chrome DevTools and Visual Studio Code to inspect code, set breakpoints and identify errors during execution.

Debugging with Chrome DevTools

Debugging Node.js with Chrome DevTools involves utilizing Chrome DevTools to inspect and debug Node.js applications, set breakpoints, examine variables and identify issues during execution.

Code:

function addNumbers(num1, num2) {
       debugger;
        return num1 + num2;
}
console.log(addNumbers(4, 4));

Output:

8

Explanation:

The debugger statement pauses execution when the application is being debugged which allows developers to inspect the code and variables. The function then returns the sum of 4 and 4 which is 8.

Debugging with VS Code

Debugging with VS Code helps developers to identify, inspect and fix errors by running step-by-step and examining variables during execution. Let us see an example to understand this.

Code:

function addNumbers(num1, num2) {
     debugger;

     return num1 + num2;

}
console.log(addNumbers(6, 6));

Output:

12

Explanation:

In this example, the debugger statement pauses execution when the application is running under the VS Code debugger which allows developers to inspect the values of num1 and num2 before the function returns their sum.  

Using the debugger Statement

The JavaScript debugger statement acts as a programmatic breakpoint. When encountered while a debugger is active then it pauses program execution and permits developers to inspect the code and variables.

Code:

function calculateTotalPrice(price, tax) {
    let subtotal = price * 1.05;

    debugger;

    let total = subtotal + tax;

    return total;
}
console.log(calculateTotalPrice(100, 5));

Output:

110

Explanation:

We first calculate the subtotal by increasing the price by 5%. The debugger statement pauses execution. It allows us to inspect the value of subtotal. The tax is then added to the subtotal to calculate the total price.

How to Start Node.js Debugger

Node.js provides the built-in inspect command to start the debugger. Open the terminal in your project directory and run the command below:

Syntax:

node inspect app.js

The above command starts the Node.js debugger and lets us debug the app.js file using debugger commands such as next, step and cont. Now you can use the debugger commands to control program execution and inspect your code.

Difference between --inspect and --inspect-brk

The difference between --inspect and --inspect-brk is given in the table below:

Common Node.js Debugger Commands

Node.js supports multiple commands to control the debugger. These commands allow us to navigate through various parts of the script execution and inspect values at different stages. Let us understand these commands with the help of the table below: