Node.js Interview Questions

The Node.js event loop is a fundamental concept that enables Node.js to perform non-blocking I/O operations despite its single-threaded nature. It is a continuous loop that checks for tasks to perform and executes them, allowing Node.js to handle a large number of concurrent connections efficiently without blocking the main thread.

What is the Event Loop?

At its core, Node.js uses a single main thread for executing JavaScript code. To avoid blocking this thread during long-running operations like database queries or network requests, it offloads these operations to the underlying system kernel whenever possible. Once these operations complete, the kernel notifies Node.js, and the event loop ensures their callbacks are executed at the appropriate time.

How it Works

The event loop is part of the libuv library, which provides a cross-platform asynchronous I/O API. It manages a queue of pending operations and their corresponding callbacks. When the call stack is empty, the event loop takes the next callback from the queue and pushes it onto the call stack for execution. This process is continuous, cycling through different phases.

• Timers: Executes callbacks scheduled by setTimeout() and setInterval().
• Pending Callbacks: Executes I/O callbacks deferred from the previous loop iteration.
• Poll: Retrieves new I/O events and executes their callbacks. This is where most asynchronous operations complete.
• Check: Executes setImmediate() callbacks.
• Close Callbacks: Handles 'close' event callbacks.

Phases of the Event Loop

1. Timers Phase

This phase executes callbacks scheduled by setTimeout() and setInterval(). It checks if the timer's threshold has been met, and if so, executes the associated callback.

2. Pending Callbacks Phase

This phase executes callbacks for system operations, like some TCP errors, that were deferred from the previous iteration.

3. Poll Phase

This is the most critical phase. It retrieves new I/O events, such as file reads, network requests, etc. It then executes callbacks for these events immediately. If there are no pending timers or setImmediate() callbacks, the event loop might block here, waiting for new I/O events.

4. Check Phase

This phase allows setImmediate() callbacks to be executed. setImmediate() is similar to setTimeout(fn, 0) but executes in a different phase of the event loop.

5. Close Callbacks Phase

This phase executes callbacks associated with a close event, such as when a socket or handle is explicitly closed (socket.destroy()).

Event Loop and Microtasks (Microtask Queue)

Beyond the main event loop phases, Node.js also handles microtasks. These include process.nextTick() callbacks and Promise callbacks (e.g., .then(), .catch(), .finally()). Microtasks have higher priority and are executed immediately after the current operation finishes and before the event loop moves to the next phase.

console.log('start');

setTimeout(() => {
  console.log('setTimeout callback');
}, 0);

process.nextTick(() => {
  console.log('process.nextTick callback');
});

Promise.resolve().then(() => {
  console.log('Promise resolve callback');
});

console.log('end');

// Expected Output Order:
// start
// end
// process.nextTick callback
// Promise resolve callback
// setTimeout callback

Conclusion

The Node.js event loop is critical for its asynchronous, non-blocking nature. Understanding its phases and how it prioritizes different types of tasks is essential for writing efficient and performant Node.js applications that can handle concurrency effectively without resorting to multi-threading for most I/O operations.