Why timing matters in Node.js in Node.js - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why does Node.js use an event loop?

Node.js uses an event loop to handle tasks. What is the main reason for this design?

A To use multiple CPU cores automatically without extra code.

B To make Node.js run slower but more securely.

C To force all tasks to run one after another, blocking the program.

D To allow Node.js to perform non-blocking operations and handle many tasks at once.

💡 Hint

Think about how Node.js handles many users or tasks without waiting for each to finish.

Node.js uses an event loop to perform non-blocking operations, allowing it to handle many tasks concurrently without waiting for each to finish before starting the next.

❓ component_behavior

intermediate

What happens when you call setTimeout with 0 ms in Node.js?

Consider this code snippet in Node.js: setTimeout(() => console.log('Timeout done'), 0); console.log('After setTimeout'); What will be the order of the printed lines?

Node.js

setTimeout(() => console.log('Timeout done'), 0);
console.log('After setTimeout');

A Only After setTimeout

B

Timeout done
After setTimeout

C

After setTimeout
Timeout done

D Only Timeout done

💡 Hint

Remember that even 0 ms delay means the callback waits for the current code to finish.

setTimeout with 0 ms schedules the callback after the current call stack is empty, so 'After setTimeout' prints first, then 'Timeout done'.

❓ state_output

advanced

What is the output of this asynchronous code?

Analyze this Node.js code: console.log('Start'); setImmediate(() => console.log('Immediate')); process.nextTick(() => console.log('Next Tick')); console.log('End');

Node.js

console.log('Start');
setImmediate(() => console.log('Immediate'));
process.nextTick(() => console.log('Next Tick'));
console.log('End');

A

Start
End
Next Tick
Immediate

B

Start
Immediate
Next Tick
End

C

Start
Next Tick
End
Immediate

D

Next Tick
Start
End
Immediate

💡 Hint

process.nextTick runs before other asynchronous callbacks, but after current code.

The synchronous logs 'Start' and 'End' run first. Then process.nextTick callback runs before setImmediate, so order is Start, End, Next Tick, Immediate.

📝 Syntax

advanced

Which code snippet correctly schedules a callback after I/O events in Node.js?

You want to run a function after I/O events callbacks. Which of these options is correct?

A process.nextTick(() => console.log('After I/O events'));

B setImmediate(() => console.log('After I/O events'));

C setTimeout(() => console.log('After I/O events'), 0);

D Promise.resolve().then(() => console.log('After I/O events'));

💡 Hint

Which callback runs in the check phase of the event loop?

setImmediate callbacks run after I/O events in the event loop, making them suitable to run code after I/O callbacks.

🔧 Debug

expert

Why does this Node.js code never print 'Done'?

Look at this code: function wait() { setTimeout(() => { wait(); }, 0); } wait(); console.log('Done'); Why is 'Done' never printed?

Node.js

function wait() {
  setTimeout(() => {
    wait();
  }, 0);
}

wait();
console.log('Done');

A 'Done' is printed immediately because console.log runs synchronously.

B 'Done' is never printed because wait() blocks the event loop forever.

C 'Done' is printed after many recursive calls finish.

D 'Done' is never printed because the program crashes with a stack overflow.

💡 Hint

Consider when console.log runs compared to setTimeout callbacks.

console.log('Done') runs immediately after wait() is called because wait schedules callbacks asynchronously. The program does not block or crash, so 'Done' prints right away.