Predict-the-Output Questions

The output is one, six, four, three, five, two. Working through why is the whole point of the exercise.

console.log("1");

setTimeout(() => console.log("2"), 0);

Promise.resolve().then(() => console.log("3"));

(async () => {
  console.log("4");
  await null;
  console.log("5");
})();

console.log("6");

The synchronous pass comes first and prints one, four and six. The async function body runs synchronously up to its first await, so four is printed during that pass, in the middle. The await then suspends the function and schedules its continuation.

Next comes the microtask queue. The promise callback for three was registered before the async function even ran, so it is ahead in the queue, and the continuation of the async function is behind it. So three prints, then the continuation runs and prints five.

Finally the timer task runs and prints two. A timer with a zero delay still waits until the current task and the whole microtask queue are finished.

Three rules explain the whole thing. Synchronous code runs in order. The microtask queue is drained completely before the next macrotask. And an await is a microtask, so it never runs before the promise callbacks that were queued ahead of it.

Do not guess. Work through it in a fixed order, and say your reasoning out loud, because the interviewer is usually grading the reasoning more than the answer.

Step one is to sort every line into a bucket. Synchronous statements go in the first bucket. Microtask sources go in the second, which means promise callbacks, the queueMicrotask function, and the continuation of any async function that hits an await. Macrotask sources go in the third, which means timers, network callbacks and event handlers.

Step two is to run the first bucket in order. Anything that runs during this pass also produces new microtasks, so note them as you go. The important subtlety is that an async function body counts as synchronous up to its first await, and the continuation after the await is a microtask.

Step three is to drain the second bucket, in the order the entries were queued. Keep draining, because a microtask can queue another microtask.

Step four is to take the first entry of the third bucket, run it, and then drain the microtask queue again before taking the next macrotask.

Two questions to ask yourself while you work. Was anything registered before or after the code that queued it? And is this a case where the ordering depends on registration order rather than on timing? Almost every surprise in these puzzles comes from one of those two, and almost never from the delay values themselves.

Finally, if you are unsure, say what you are unsure about and what you would check. That is exactly how you would investigate it at work, and it earns more credit than a confident wrong answer.