Event loop phases and timer execution in Node.js

Introduction

The event loop lets Node.js do many things at once by managing tasks in steps called phases. Timers run in a special phase to schedule code after a delay.

When you want to run code after a delay or repeatedly at intervals.

When you need to understand why some callbacks run before others in Node.js.

When debugging why some asynchronous code runs later than expected.

When optimizing performance by knowing how Node.js handles tasks in order.

Syntax

Node.js

setTimeout(callback, delay)
setInterval(callback, delay)

setTimeout runs the callback once after the delay (in milliseconds).

setInterval runs the callback repeatedly every delay milliseconds.

Examples

This runs the message once after 1 second.

Node.js

setTimeout(() => {
  console.log('Hello after 1 second');
}, 1000);

This prints the message every 2 seconds until stopped.

Node.js

setInterval(() => {
  console.log('Repeats every 2 seconds');
}, 2000);

Even with 0 delay, the timeout runs after current code finishes.

Node.js

console.log('Start');
setTimeout(() => {
  console.log('Timeout');
}, 0);
console.log('End');

Sample Program

This program shows how timer callbacks run after the current code finishes, in the timers phase of the event loop. The shorter delay callback runs first.

Node.js

console.log('Phase 1: Start');

setTimeout(() => {
  console.log('Timer callback runs in timers phase');
}, 100);

setTimeout(() => {
  console.log('Another timer callback');
}, 50);

console.log('Phase 1: End');

Important Notes

Timers run in the timers phase of the event loop, after the current code completes.

Even a 0 ms delay means the callback waits until the timers phase, so it runs after synchronous code.

Callbacks with shorter delays usually run before longer delays, but exact timing depends on system and event loop state.

Summary

The event loop has phases; timers run in the timers phase.

setTimeout schedules code to run after a delay in the timers phase.

Even zero delay callbacks run after current synchronous code finishes.

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