Node.js is a JavaScript runtime in response to the similar V8 engine utilized in Google’s Chrome browser. It’s frequently used to construct cross-platform server-side and terminal packages. Node.js has become increasingly popular over the last decade as it’s easy to install, sensible to make use of, rapid, and lets in client-side internet builders to leverage their skills elsewhere.

Then again, device construction stays a fancy process, and your Node.js code will fail in the future. This instructional demonstrates more than a few gear to assist debug packages and in finding the reason for an issue.

Let’s dive appropriate in.

Debugging Assessment

“Debugging” is the identify given to the more than a few way of changing device defects. Solving a malicious program is frequently simple. Discovering the reason for the malicious program can also be significantly extra complicated and incur many hours of head-scratching.

The next sections describe 3 normal sorts of error you are going to come across.

Syntax Mistakes

Your code does now not observe the foundations of the language — for instance, while you put out of your mind a ultimate bracket or misspell a remark corresponding to console.lag(x).

A just right code editor can assist spot commonplace issues by means of:

  • Colour-coding legitimate or invalid statements
  • Kind-checking variables
  • Auto-completing serve as and variable names
  • Highlighting matching brackets
  • Auto-indenting code blocks
  • Detecting unreachable code
  • Refactoring messy purposes

Free editors corresponding to VS Code and Atom have nice strengthen for Node.js, JavaScript, and TypeScript (which transpiles to JavaScript). Elementary syntax issues can normally be noticed sooner than you save and check your code.

A code linter like ESLint may also document syntax mistakes, dangerous indentation, and undeclared variables. ESLint is a Node.js software you’ll set up globally with:

npm i eslint -g

You’ll be able to verify JavaScript recordsdata from the command line the use of:

eslint mycode.js

…however it’s more uncomplicated to make use of an editor plugin corresponding to ESLint for VS Code or linter-eslint for Atom, which robotically validate code as you kind:

ESlint in VS Code
ESlint in VS Code.

Good judgment Mistakes

Your code runs however does now not paintings as you are expecting. As an example, a consumer isn’t logged out after they request it; a document displays wrong figures; knowledge isn’t absolutely stored to a database; and so on.

Good judgment mistakes can also be led to by means of:

  • The usage of the fallacious variable
  • Flawed prerequisites, e.g. if (a > 5) fairly than if (a < 5)
  • Calculations that fail to account for operator priority, e.g. 1+2*3 leads to 7 fairly than 9.

It's inevitable: your Node.js code will fail at some point. 😅 See what tools you can use to debug applications and find the cause of a problem right here ✅Click to Tweet

Runtime (or Execution) Mistakes

An error solely turns into obtrusive when the applying is accomplished, which frequently results in a crash. Runtime mistakes may well be led to by means of:

  • Dividing by means of a variable that has been set to 0
  • Making an attempt to get entry to an array merchandise that doesn't exist
  • Looking to write to a read-only report

Good judgment and runtime mistakes are harder to identify, even though the next construction ways can assist:

  1. Use Take a look at-Pushed Building: TTD encourages you to put in writing exams sooner than a serve as is advanced, e.g. X is returned from functionY when Z is handed as a parameter. Those exams are run throughout the preliminary construction and next updates to make sure the code continues to paintings as anticipated.
  2. Use a topic monitoring gadget: There may be not anything worse than an electronic mail claiming “Your device doesn’t paintings”! Factor monitoring techniques assist you to report particular problems, report copy steps, resolve priorities, assign builders, and monitor the development of fixes.
  3. Use supply regulate: A supply regulate gadget such as Git will assist you to again up code, organize revisions, and establish the place a malicious program was once presented. On-line repositories, together with Github and Bitbucket, supply unfastened house and gear for smaller or open-source tasks.

You'll nonetheless come across Node.js insects, however the next sections describe tactics to find that elusive error.

Set Suitable Node.js Atmosphere Variables

Atmosphere variables set within the host running gadget can regulate Node.js software and module settings. The commonest is NODE_ENV, which generally is ready to construction when debugging or manufacturing when operating on a are living server. Set surroundings variables on macOS or Linux with:


or on the (vintage) Home windows command suggested:

set NODE_ENV=construction

or Home windows Powershell:


In the preferred Express.js framework, surroundings NODE_ENV to construction disables template report caching and outputs verbose error messages, which may well be useful when debugging. Different modules would possibly be offering identical options, and you'll upload a NODE_ENV situation on your packages, e.g.

// operating in construction mode?
const devMode = (procedure.env.NODE_ENV !== 'manufacturing');

if (devMode) {
  console.log('software is operating in construction mode');

You'll be able to additionally use Node’s util.debuglog strategy to conditionally output error messages, e.g.

import { debuglog } from 'util';
const myappDebug = debuglog('myapp');
myappDebug('log one thing');

This software will solely output the log message when NODE_DEBUG is ready to myapp or a wildcard corresponding to * or my*.

Use Node.js Command Line Choices

Node scripts are normally introduced with node adopted by means of the identify of the access script:

node app.js

You'll be able to additionally set command line options to regulate more than a few runtime facets. Helpful flags for debugging come with:

  • --check
    syntax verify the script with out executing
  • --trace-warnings
    output a stack hint when JavaScript Guarantees don't unravel or reject
  • --enable-source-maps
    display supply maps when the use of a transpiler corresponding to TypeScript
  • --throw-deprecation
    warn when deprecated Node.js options are used
  • --redirect-warnings=report
    output warnings to a report fairly than stderr
  • --trace-exit
    output a stack hint when procedure.go out() is named.

Output Messages to the Console

Outputting a console message is likely one of the most straightforward tactics to debug a Node.js software:

console.log(`someVariable: ${ someVariable }`);

Few builders notice there are lots of different console strategies:

Console Way Description
.log(msg) same old console message
.log('%j', obj) output object as a compact JSON string
.dir(obj, choose) pretty-print object homes
.desk(obj) output arrays and items in tabular structure
.error(msg) an error message
.depend(label) increment a named counter and output
.countReset(label) reset a named counter
.team(label) indent a bunch of messages
.groupEnd(label) terminate a bunch
.time(label) begins a named timer
.timeLog(label) reviews the elapsed time
.timeEnd(label) stops a named timer
.hint() output a stack hint (a listing of all serve as calls made)
.transparent() transparent the console

console.log() additionally accepts a listing of comma-separated values:

let x = 123;
console.log('x:', x);
// x: 123

…despite the fact that ES6 destructuring gives identical output with much less effort:

console.log({ x });
// { x: 123 }

The console.dir() command pretty-prints object homes in the similar manner as util.inspect():

console.dir(myObject, { intensity: null, colour: true });

Console Controversy

Some builders declare you will have to by no means use console.log() as a result of:

  • You’re converting code and would possibly modify one thing or overlook to take away it, and
  • There’s little need when there are higher debugging choices.

Don’t imagine someone who claims they by no means use console.log()! Logging is fast and grimy, however everybody makes use of it in the future. Use no matter software or methodology you like. Solving a malicious program is extra necessary than the process you undertake to search out it.

Use a 3rd-Birthday party Logging Gadget

3rd-party logging techniques supply extra subtle options corresponding to messaging ranges, verbosity, sorting, report output, profiling, reporting, and extra. Standard answers come with cabin, loglevel, morgan, pino, signale, storyboard, tracer, and winston.

Use the V8 Inspector

The V8 JavaScript engine supplies a debugging client which you'll use in Node.js. Get started an software the use of node examine, e.g.

node examine app.js

The debugger pauses on the first line and presentations a debug> suggested:

$ node examine .mycode.js
< Debugger listening on ws://
< For assist, see:
< Debugger connected.
Break on start in mycode.js:1
> 1 const depend = 10;
  3 for (i = 0; i < counter; i++) {

Input assist to view a listing of instructions. You'll be able to step throughout the software by means of coming into:

  • cont or c: proceed execution
  • subsequent or n: run the following command
  • step or s: step right into a serve as being referred to as
  • out or o: step out of a serve as and go back to the calling remark
  • pause: pause operating code
  • watch(‘myvar’): watch a variable
  • setBreakPoint() or sb(): set a breakpoint
  • restart: restart the script
  • .go out or Ctrl | Cmd + D: go out the debugger

Admittedly, this debugging possibility is time-consuming and unwieldy. Handiest use it when there’s no different possibility, like while you’re operating code on a far off server and can not attach from in other places or set up further device.

Use the Chrome Browser to Debug Node.js Code

The Node.js examine possibility used above begins a Internet Socket server that listens on localhost port 9229. It additionally begins a text-based debugging Jstomer, however it’s imaginable to make use of graphical purchasers — such because the one built into Google Chrome and Chrome-based browsers like Chromium, Edge, Opera, Vivaldi, and Brave.

To debug a normal internet software, get started it with the –examine technique to allow the V8 debugger’s Internet Socket server:

node --inspect index.js

Be aware:

  • index.js is presumed to be the applying’s access script.
  • Be sure to use --inspect with double dashes to make sure you don't get started the text-based debugger Jstomer.
  • You'll be able to use nodemon as a substitute of node if you wish to auto-restart the applying when a report is modified.

By means of default, the debugger will solely settle for incoming connections from the native gadget. In case you’re operating the applying on some other instrument, digital gadget, or Docker container, use:

node --inspect= index.js
node inspect
node examine possibility.

You'll be able to additionally use --inspect-brk as a substitute of --inspect to halt processing (set a breakpoint) at the first line so you'll step throughout the code from the beginning.

Open a Chrome-based browser and input chrome://examine within the deal with bar to view native and networked gadgets:

Chrome inspect tool
Chrome examine software.

In case your Node.js software does now not seem as a Far flung Goal, both:

  • Click on Open devoted DevTools for Node and make a choice the deal with and port, or
  • Test Uncover community objectives, click on Configure, then upload the IP deal with and port of the instrument the place it’s operating.

Click on the Goal’s examine hyperlink to release the DevTools debugger Jstomer. This will have to be acquainted to someone who’s used DevTools for client-side code debugging:

Chrome DevTools
Chrome DevTools.

Transfer to the Assets panel. You'll be able to open any report by means of hitting Cmd | Ctrl + P and coming into its filename (corresponding to index.js).

Then again, it’s more uncomplicated so as to add your mission folder to the workspace. This permits you to load, edit, and save recordsdata at once from DevTools (whether or not you suppose that’s a good suggestion is some other subject!)

  1. Click on + Upload folder to workspace
  2. Make a choice the positioning of your Node.js mission
  3. Hit Agree to allow report adjustments

You'll be able to now load recordsdata from the left-hand listing tree:

Chrome DevTools Sources panel
Chrome DevTools Assets panel.

Click on any line quantity to set a breakpoint denoted by means of a blue marker.

Debugging is in response to breakpoints. Those specify the place the debugger will have to pause program execution and display the present state of this system (variables, name stack, and so on.)

You'll be able to outline any selection of breakpoints within the consumer interface. An alternative choice is to position a debugger; remark into your code, which stops when a debugger is hooked up.

Load and use your internet software to succeed in the remark the place a breakpoint is ready. Within the instance right here, http://localhost:3000/ is opened in any browser, and DevTools will halt execution on line 44:

Chrome breakpoint
Chrome breakpoint.

The best-hand panel displays:

Suffering with downtime and WordPress issues? Kinsta is the web hosting resolution designed to avoid wasting you time! Check out our features
  • A row of motion icons (see under).
  • A Watch pane permits you to observe variables by means of clicking the + icon and coming into their names.
  • A Breakpoints pane displays a listing of all breakpoints and lets them be enabled or disabled.
  • A Scope pane displays the state of all native, module, and world variables. You'll examine this pane maximum frequently.
  • A Name Stack pane displays the hierarchy of purposes referred to as to succeed in this level.

A row of motion icons is proven above Paused on breakpoint:

Chrome breakpoint icons
Chrome breakpoint icons.

From left to appropriate, those carry out the next movements:

  • resume execution: Proceed processing till the following breakpoint
  • step over: Execute the following command however keep inside the present code block — don't bounce into any serve as it calls
  • step into: Execute the following command and bounce into any serve as as vital
  • step out: Proceed processing to the tip of the serve as and go back to the calling command
  • step: Very similar to step into excluding it'll now not bounce into async purposes
  • deactivate all breakpoints
  • pause on exceptions: Halt processing when an error happens.

Conditional Breakpoints

Every now and then it’s vital to wield a bit extra regulate over breakpoints. Believe you may have a loop that finished 1,000 iterations, however you’re solely within the state of the ultimate one:

for (let i = 0; i < 1000; i++) {
  // set breakpoint right here

Fairly than clicking resume execution 999 instances, you'll right-click the road, make a choice Upload conditional breakpoint, and input a situation corresponding to i = 999:

Chrome conditional breakpoint
Chrome conditional breakpoint.

Chrome displays conditional breakpoints in yellow fairly than blue. On this case, the breakpoint is solely brought on at the ultimate iteration of the loop.

Log Issues

Log issues successfully put into effect console.log() with none code! An expression can also be output when the code executes any line, however it does now not halt processing, in contrast to a breakpoint.

So as to add a log level, right-click any line, make a choice Upload log level, and input an expression, e.g. 'loop counter i', i:

Chrome logpoint
Chrome log level.

The DevTools console outputs loop counter i: 0 to loop counter i: 999 within the instance above.

Use VS Code to Debug Node.js Programs

VS Code, or Visible Studio Code, is a unfastened code editor from Microsoft that’s grow to be well liked by web developers. The applying is to be had for Home windows, macOS, and Linux and is advanced the use of internet applied sciences within the Electron framework.

VS Code helps Node.js and has a integrated debugging Jstomer. Maximum packages can also be debugged with none configuration; the editor will robotically get started the debugging server and Jstomer.

Open the beginning report (corresponding to index.js), turn on the Run and Debug pane, click on the Run and Debug button, and make a choice the Node.js surroundings. Click on any line to turn on a breakpoint proven as a pink circle icon. Then, open the applying in a browser as sooner than — VS Code halts execution when the breakpoint is reached:

VS Code breakpoint
VS Code breakpoint.

The Variables, Watch, Name Stack, and Breakpoints panes are very similar to the ones proven in Chrome DevTools. The Loaded Scripts pane displays which scripts had been loaded, despite the fact that many are inside to Node.js.

The toolbar of motion icons permits you to:

  • resume execution: Proceed processing till the following breakpoint
  • step over: Execute the following command however keep inside the present serve as — don't bounce into any serve as it calls
  • step into: Execute the following command and bounce into any serve as it calls
  • step out: Proceed processing to the tip of the serve as and go back to the calling command
  • restart the applying and debugger
  • forestall the applying and debugger

Like Chrome DevTools, you'll right-click any line so as to add Conditional breakpoints and Log issues.

For more info, consult with Debugging in Visual Studio Code.

VS Code Complicated Debugging Configuration

Additional VS Code configuration could also be vital if you wish to debug code on some other instrument, a digital gadget, or wish to use selection release choices corresponding to nodemon.

VS Code shops debugging configurations in a release.json report inside of a .vscode listing to your mission. Open the Run and Debug pane, click on create a release.json report, and make a choice the Node.js surroundings to generate this report. An instance configuration is equipped:

VS Code debugger configuration
VS Code debugger configuration.

Any selection of configuration settings can also be outlined as items within the "configurations" array. Click on Upload Configuration… and make a selection an acceptable possibility.

A person Node.js configuration can both:

  1. Release a procedure itself, or
  2. Connect to a debugging Internet Socket server, most likely operating on a far off gadget or Docker container.

As an example, to outline a nodemon configuration, make a selection Node.js: Nodemon Setup and alter the “program” access script if vital:

  // customized configuration
  "model": "0.2.0",
  "configurations": [
      "console": "integratedTerminal",
      "internalConsoleOptions": "neverOpen",
      "name": "nodemon",
      "program": "${workspaceFolder}/index.js",
      "request": "launch",
      "restart": true,
      "runtimeExecutable": "nodemon",
      "skipFiles": [
      "kind": "pwa-node"

Save the release.json report and nodemon (the configuration “identify”) seems within the drop-down record on the best of the Run and Debug pane. Click on the fairway run icon to begin the use of that configuration and release the applying the use of nodemon:

VS Code debugging with nodemon
VS Code debugging with nodemon.

As sooner than, you'll upload breakpoints, conditional breakpoints, and log issues. The principle distinction is that nodemon will robotically restart your server when a report is changed.

For additional knowledge, consult with VS Code Launch configurations.

The next VS Code extensions too can assist you to debug code hosted on far off or remoted server environments:

Different Node.js Debugging Choices

The Node.js Debugging Guide supplies recommendation for a spread of textual content editors and IDEs, together with Visible Studio, JetBrains WebStorm, Gitpod, and Eclipse. Atom gives a node-debug extension, which integrates the Chrome DevTools debugger into the editor.

As soon as your software is are living, it is advisable believe the use of business debugging services and products corresponding to LogRocket and, which is able to report and playback Jstomer and server mistakes encountered by means of actual customers.

Need some help debugging applications? 🐛 Start here 👇Click to Tweet


Traditionally, JavaScript debugging has been tricky, however there were massive enhancements over the last decade. The selection is as just right — if now not higher — than the ones equipped for different languages.

Use no matter software is sensible to find an issue. There’s not anything fallacious with console.log() for speedy malicious program looking, however Chrome DevTools or VS Code could also be preferable for extra complicated problems. The gear permit you to create extra tough code, and also you’ll spend much less time solving insects.

What Node.js debugging observe do you swear by means of? Proportion within the feedback phase under!

The publish How to Debug Node.js Code Using Multiple Tools seemed first on Kinsta®.

WP Hosting

[ continue ]