Node.js built-in debugger in Node.js - Step-by-Step Execution

Concept Flow - Node.js built-in debugger

Start Node.js with --inspect

↓

Debugger listens on port

↓

Connect debugger client

↓

Set breakpoints

↓

Run code until breakpoint

↓

Pause execution

↓

Inspect variables & call stack

↓

Step through code (step in/out/over)

↓

Resume or stop debugging

This flow shows how Node.js debugger starts, listens, connects, pauses, inspects, steps, and resumes code execution.

Execution Sample

Node.js

node --inspect-brk app.js
// In debugger client:
break app.js:5
cont
next
repl

Starts Node.js with debugger, sets breakpoint at line 5, continues, steps next, and opens REPL for inspection.

Execution Table

Step	Debugger Action	Code Execution State	Variables State	Output/Effect
1	Start Node.js with --inspect-brk	Execution paused before first line	No variables initialized	Debugger listening on ws://127.0.0.1:9229/uuid
2	Connect debugger client	Paused at first line	No variables initialized	Client connected, ready to send commands
3	Set breakpoint at app.js:5	Breakpoint set	No variables initialized	Breakpoint registered at line 5
4	Continue execution (cont)	Runs until line 5	Variables initialized up to line 4	Execution paused at breakpoint line 5
5	Inspect variables	Paused at line 5	Variables visible with current values	Variables shown in debugger UI
6	Step over (next)	Executes line 5, pauses at line 6	Variables updated if changed	Execution paused at line 6
7	Open REPL	Paused at line 6	Variables accessible	User can evaluate expressions interactively
8	Resume execution	Runs to end or next breakpoint	Variables update as code runs	Program continues running
9	Exit debugger	Program runs normally	Variables as per program end	Debugger detached

💡 Debugger session ends when user detaches or program finishes execution

Variable Tracker

Variable	Start	After Step 4	After Step 6	Final
count	undefined	3	4	10
message	undefined	'start'	'processing'	'done'

Key Moments - 3 Insights

Why does the program pause immediately when using --inspect-brk?

Because --inspect-brk tells Node.js to pause execution before running any code, allowing you to set breakpoints before the program starts (see execution_table step 1).

How can I see the current value of a variable while paused?

Use the debugger's inspect or REPL commands to evaluate variables at the paused line, as shown in execution_table steps 5 and 7.

What is the difference between 'next' and 'cont' commands?

'cont' continues running until the next breakpoint or program end, while 'next' steps over the current line and pauses at the next line (see steps 4 and 6).

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the debugger pause at the user-set breakpoint?

A Step 6

B Step 2

C Step 4

D Step 1

💡 Hint

Check the 'Code Execution State' column for when execution pauses at line 5.

According to variable_tracker, what is the value of 'count' after step 6?

A 3

B 4

C undefined

D 10

💡 Hint

Look at the 'After Step 6' column for variable 'count'.

If you remove the --inspect-brk flag, what changes in the execution flow?

A Program runs immediately until breakpoint

B Program pauses before first line

C Debugger does not listen on any port

D Cannot set breakpoints

💡 Hint

Compare step 1 description about --inspect-brk pausing before first line.

Concept Snapshot

Node.js built-in debugger:
- Start with 'node --inspect' or '--inspect-brk' to enable debugging
- Connect debugger client (Chrome DevTools, VSCode)
- Set breakpoints to pause execution
- Use 'cont' to continue, 'next' to step over lines
- Inspect variables and call stack while paused
- Use REPL for interactive evaluation
- Resume or detach to end debugging

Full Transcript

The Node.js built-in debugger allows you to pause and inspect your code while it runs. You start Node.js with the --inspect or --inspect-brk flag. The --inspect-brk flag pauses execution before the first line, letting you set breakpoints early. Then you connect a debugger client like Chrome DevTools or VSCode. You set breakpoints where you want the program to pause. When the program hits a breakpoint, it pauses, letting you inspect variables and the call stack. You can step through code line by line using commands like 'next' or continue running with 'cont'. The REPL lets you run commands and check variable values interactively. When done, you resume or detach the debugger to let the program finish normally.