Chapter quiz · Node.js for Algorithms & Interview Patterns

Test what you learned.

8 questions on Node.js for Algorithms & Interview Patterns. Pass 70% to clear the chapter.

Quiz

Node.js & Interview Pitfalls — Chapter Quiz

Eight questions on the event loop phases, microtasks, blocking, worker threads, streams, and common JS interview gotchas.

0/ 9

Question 1
1
In what order does Node.js process the following after the current call stack is empty: a resolved Promise callback, a setTimeout(fn, 0) callback, and a queueMicrotask callback?
AsetTimeout → Promise → queueMicrotaskBPromise → queueMicrotask → setTimeoutCqueueMicrotask and Promise callbacks (both microtasks) run first, then setTimeoutDAll three run simultaneously
The microtask queue (resolved Promises and queueMicrotask) is drained completely before the event loop advances to the next phase (where setTimeout callbacks live). So microtasks always beat macrotasks.
Question 2
2
Which Node.js event loop phase processes I/O callbacks (e.g., file system, network)?
ATimers phaseBPoll phaseCCheck phase (setImmediate)DClose callbacks phase
The poll phase retrieves new I/O events and executes their callbacks. If the poll queue is empty, Node either waits for I/O or moves on if timers are ready. setImmediate callbacks run in the check phase, which comes after poll.
Question 3
3
A Node.js HTTP server handles 1,000 concurrent requests. A single request triggers a CPU-intensive operation that takes 2 seconds synchronously. What happens?
AOnly that request is delayed; others continue normallyBThe entire event loop is blocked for 2 seconds — all other requests stop being processedCNode.js automatically spawns a new thread for the blocking workDThe request is queued and processed after 2 seconds with no impact on others
Node.js runs JS on a single thread. Synchronous CPU work blocks the event loop, freezing I/O, timers, and all other request handling for the duration. Offload CPU work to worker_threads or a child process.
Question 4
4
Which Node.js API is the correct choice for CPU-intensive work (e.g., image compression, cryptographic hashing) that must not block the event loop?
AsetImmediate — defers execution to the next iterationBprocess.nextTick — runs before I/OCworker_threads — runs JS in a separate OS thread with its own V8 instanceDPromise.all — parallelises work automatically
worker_threads runs JavaScript in a true parallel OS thread. Workers can share SharedArrayBuffer memory and communicate via postMessage. setImmediate and nextTick are still on the main thread; Promise.all only parallelises async I/O.
Question 5
5
Why should you use Node.js streams when processing a 10 GB log file?
AStreams are always faster than reading the file at onceBStreams process data in chunks, keeping memory usage constant (~64 KB per chunk by default) instead of loading the entire file into RAMCStreams automatically compress the file during readingDfs.readFile is not available for files larger than 2 GB
fs.readFile buffers the entire file in memory. A 10 GB file would exhaust typical Node.js heap limits. Readable streams emit data events in small chunks, enabling processing of arbitrarily large files with bounded memory.
Question 6
6
Modifying an array while iterating over it with a for...of loop is always safe in JavaScript.
TTrueFFalse
for...of uses the array's iterator. Removing or inserting elements while iterating shifts indices and can cause elements to be skipped or visited twice. Iterate over a copy or collect indices first, then modify.
Question 7
7
The default comparator for Array.prototype.sort() converts elements to ___ before comparing, which causes numeric arrays to sort incorrectly without an explicit comparator.
Without a comparator, sort calls toString() on each element and compares UTF-16 code unit sequences. [10, 9, 2].sort() → [10, 2, 9] because "10" < "2". Fix: .sort((a, b) => a - b).
Question 8
8
Which of the following are common JavaScript/Node.js pitfalls in coding interviews? (Select all that apply)
Select all that apply.
AUsing Array.shift() as a queue dequeue operation, causing O(n) per callBCalling .sort() on a number array without a comparator and getting lexicographic orderCAssuming typeof null === \"object\" is a bug in your code rather than a language quirkDMutating an array while iterating over it with forEach or for...of
Array.shift() is O(n), the default sort is lexical, and mutating during iteration causes subtle bugs — all three trip up candidates. typeof null === 'object' is a well-known historical quirk of the language, not a code bug you introduced.