Event loop phases and timer execution in Node.js - Step-by-Step Execution

Concept Flow - Event loop phases and timer execution

Start Event Loop

↓

Timers Phase

↓

Pending Callbacks Phase

↓

Idle, Prepare Phase

↓

Poll Phase

↓

Check Phase

↓

Close Callbacks Phase

↓

Repeat Event Loop

The Node.js event loop runs in phases, each handling specific callbacks like timers, I/O, and close events, cycling continuously.

Execution Sample

Node.js

setTimeout(() => console.log('timer1'), 0);
setImmediate(() => console.log('immediate1'));
console.log('start');

This code schedules a timer and an immediate callback, then logs 'start' immediately.

Execution Table

Step	Phase	Action	Callback Executed	Output
1	Main script	Execute synchronous code	None	start
2	Timers phase	Execute timer callbacks	timer1 callback	timer1
3	Pending Callbacks	No callbacks	None
4	Idle, Prepare	Internal setup	None
5	Poll phase	Check for I/O callbacks	None
6	Check phase	Execute immediate callbacks	immediate1 callback	immediate1
7	Close callbacks	No callbacks	None
8	Event loop repeats	Cycle continues	Depends on new events

💡 Event loop runs continuously until no more callbacks or process exit

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 6	Final
Timers queue	empty	timer1 scheduled	timer1 executed	empty	empty
Immediates queue	empty	immediate1 scheduled	immediate1 pending	immediate1 executed	empty
Console output		start	start, timer1	start, timer1, immediate1	start, timer1, immediate1

Key Moments - 3 Insights

Why does 'start' print before 'timer1' even though timer1 has 0 delay?

'start' is logged during the main script execution (Step 1) before the event loop phases begin. Timer callbacks run only in the Timers phase (Step 2), so they come after synchronous code.

Why does 'immediate1' print after 'timer1' even though setImmediate is called after setTimeout?

setTimeout callbacks run in the Timers phase (Step 2), while setImmediate callbacks run in the Check phase (Step 6). The event loop processes Timers phase before Check phase, so timer1 prints first.

Can the order of timer and immediate callbacks change?

Yes, depending on when they are scheduled and the current phase of the event loop. But in this example, timers run before immediates consistently.

Visual Quiz - 3 Questions

Look at the execution table, what is printed at Step 1?

A "immediate1"

B "timer1"

C "start"

D Nothing

💡 Hint

Check the 'Output' column for Step 1 in the execution_table

At which step does the 'immediate1' callback execute?

A Step 6

B Step 1

C Step 2

D Step 4

💡 Hint

Look for 'immediate1 callback' in the 'Callback Executed' column

If setTimeout delay was increased, how would that affect the execution order?

A timer1 would run before immediate1

B immediate1 would run before timer1

C Both run at the same time

D Neither would run

💡 Hint

Consider the event loop phases and when timers vs immediates run

Concept Snapshot

Node.js event loop cycles through phases:
Timers (setTimeout/setInterval callbacks)
Pending Callbacks (I/O callbacks)
Idle, Prepare (internal)
Poll (I/O polling)
Check (setImmediate callbacks)
Close Callbacks
Timers run before immediates
Synchronous code runs before event loop phases

Full Transcript

The Node.js event loop runs continuously in phases. First, synchronous code runs immediately. Then the Timers phase executes callbacks scheduled by setTimeout or setInterval. Next phases handle I/O callbacks and internal tasks. The Check phase runs callbacks scheduled by setImmediate. This cycle repeats until no callbacks remain. In the example, 'start' logs first during synchronous execution. Then the timer callback runs in the Timers phase, printing 'timer1'. Finally, the immediate callback runs in the Check phase, printing 'immediate1'. This order is consistent because timers run before immediates in the event loop phases.

Practice

1. Which phase of the Node.js event loop executes setTimeout callbacks?

easy

A. Check phase

B. Timers phase

C. Poll phase

D. Close callbacks phase

Solution

1. Step 1: Understand event loop phases

   The Node.js event loop has multiple phases, each handling different types of callbacks.

2. Step 2: Identify where timers run

   The timers phase is specifically designed to execute callbacks scheduled by setTimeout and setInterval.

3. Final Answer:

   Timers phase -> Option B

4. Quick Check:

   Timers phase = setTimeout callbacks [OK]

Hint: Timers run in the timers phase, not immediately [OK]

Common Mistakes:

• Confusing timers phase with poll phase
• Thinking setTimeout runs immediately
• Mixing check phase with timers phase

2. Which of the following is the correct syntax to schedule a function to run after 0 milliseconds in Node.js?

easy

A. setTimeout(console.log('Hi'))

B. setTimeout(console.log('Hi'), 0);

C. setTimeout(0, () => console.log('Hi'));

D. setTimeout(() => console.log('Hi'), 0);

Solution

1. Step 1: Check function syntax for setTimeout

   The first argument must be a function, not the result of a function call.

2. Step 2: Analyze each option

   setTimeout(() => console.log('Hi'), 0); passes a function that logs 'Hi' after 0 ms delay correctly. setTimeout(console.log('Hi'), 0); calls console.log immediately and passes its result (undefined). setTimeout(0, () => console.log('Hi')); passes 0 (number) as first argument instead of a function, causing a TypeError on execution. setTimeout(console.log('Hi')) calls console.log immediately without delay argument.

3. Final Answer:

   setTimeout(() => console.log('Hi'), 0); -> Option D

4. Quick Check:

   Function as first argument = setTimeout(() => console.log('Hi'), 0); [OK]

Hint: Pass a function, not a function call, to setTimeout [OK]

Common Mistakes:

• Calling the function immediately inside setTimeout
• Omitting the delay argument
• Passing non-function as first argument

3. What will be the output order of the following code?

console.log('Start');
setTimeout(() => console.log('Timeout 1'), 0);
setTimeout(() => console.log('Timeout 2'), 10);
console.log('End');

medium

A. Start, End, Timeout 1, Timeout 2

B. Start, Timeout 1, Timeout 2, End

C. Timeout 1, Timeout 2, Start, End

D. Start, Timeout 2, End, Timeout 1

Solution

1. Step 1: Identify synchronous and asynchronous parts

   console.log('Start') and console.log('End') run immediately in order. setTimeout callbacks run later.

2. Step 2: Understand timer delays and event loop

   setTimeout with 0 ms delay runs after current code finishes, before 10 ms delay callback.

3. Final Answer:

   Start, End, Timeout 1, Timeout 2 -> Option A

4. Quick Check:

   Synchronous logs first, then timers by delay [OK]

Hint: Synchronous logs run before any setTimeout callbacks [OK]

Common Mistakes:

• Assuming 0 ms timeout runs immediately
• Mixing order of synchronous and asynchronous logs
• Ignoring timer delays

4. Identify the error in this code snippet:

setTimeout(console.log('Hello'), 1000);

medium

A. The delay argument is missing

B. The delay must be 0 or less

C. console.log is called immediately instead of after 1000ms

D. setTimeout requires a string as first argument

Solution

1. Step 1: Analyze the first argument of setTimeout

   console.log('Hello') is called immediately, returning undefined, which is passed to setTimeout.

2. Step 2: Understand correct usage

   setTimeout expects a function as first argument, not the result of a function call.

3. Final Answer:

   console.log is called immediately instead of after 1000ms -> Option C

4. Quick Check:

   Function call inside setTimeout runs immediately [OK]

Hint: Pass a function, not a function call, to setTimeout [OK]

Common Mistakes:

• Thinking delay argument is missing
• Passing string instead of function
• Believing delay must be zero or negative

5. Consider this code:

console.log('A');
setTimeout(() => console.log('B'), 0);
Promise.resolve().then(() => console.log('C'));
console.log('D');

What is the correct order of output?

hard

A. A, D, C, B

B. A, B, D, C

C. A, D, B, C

D. A, C, D, B

Solution

1. Step 1: Identify synchronous, microtask, and timers

   console.log('A') and console.log('D') run immediately. Promise.then callbacks run in microtasks after current code. setTimeout callbacks run in timers phase later.

2. Step 2: Determine execution order

   Output order is synchronous logs first (A, D), then microtasks (C), then timers (B).

3. Final Answer:

   A, D, C, B -> Option A

4. Quick Check:

   Microtasks run before timers [OK]

Hint: Promise.then runs before setTimeout even with 0 delay [OK]

Common Mistakes:

• Assuming setTimeout runs before Promise.then
• Mixing synchronous and asynchronous order
• Ignoring microtask queue priority