Output Quiz #3 — The Event Loop & Task Ordering

Output:

A
C
B

Why: console.log("A") and console.log("C") run synchronously on the call stack. setTimeout schedules "B" as a macrotask — it goes into the task queue and only runs after the current synchronous execution is complete. Even with a delay of 0, the callback never jumps the queue ahead of synchronous code.

Output:

start
end
promise
timeout

Why: Execution order: synchronous code first (start, end), then the microtask queue is drained (.then callbacks), then the task queue runs (setTimeout callbacks). Promise .then callbacks are microtasks — they always run before the next macrotask. setTimeout is a macrotask, so it waits even though its delay is 0.

Output:

sync
1
2
3

Why: console.log("sync") runs first (synchronous). Then the microtask queue is processed: the first .then runs (logs 1, returns 2), which schedules the second .then as a new microtask (logs 2, returns 3), which schedules the third (logs 3). Each .then callback is enqueued only after the previous one completes.

Output:

sync
micro
macro

Why: queueMicrotask explicitly enqueues a microtask — same queue as Promise.then. The microtask queue is drained completely after each task, before the next macrotask runs. So order is: synchronous → microtasks → macrotasks.

Output:

before
foo start
after
foo after await

Why: foo() is called synchronously. Inside foo, "foo start" logs immediately. Then await Promise.resolve() suspends foo — it schedules the rest of the function ("foo after await") as a microtask and returns control to the caller. "after" logs synchronously. Then the microtask runs: "foo after await".

Output:

1
4
2
3

Why: run() executes synchronously until the first await null. At that point it suspends, returning control: 4 logs. Then the microtask for the resumed run() fires: 2 logs. The second await null suspends again, but there's no more synchronous code, so the next microtask fires immediately: 3 logs.

Output:

A
B
D
C

Why: The Promise executor function ((resolve) => { ... }) runs synchronously when the Promise is constructed. So "B" logs immediately. The .then callback ("C") is a microtask — it runs after all synchronous code ("D") completes.

Output:

1
3
4
2

Why: Both outer setTimeouts are queued as macrotasks. The first runs: logs 1, schedules a new macrotask for 2, logs 3. Then the second outer setTimeout runs (it was queued before the inner one): logs 4. Finally the innermost setTimeout runs: logs 2. Nested setTimeout pushes to the back of the task queue, behind already-scheduled tasks.

Output:

start
a1
b1
end
a2

Why: a() starts synchronously: "a1" logs. await b() calls b() synchronously: "b1" logs. b() returns a resolved promise. The await suspends a() (schedules "a2" as a microtask) and returns control to a()'s caller. "end" logs. Then the microtask runs: "a2".

Output:

sync done
(hangs — "setTimeout ran" never logs in a real browser)

Why: Each microtask schedules another microtask before the engine can drain the queue. The microtask queue is fully drained before any macrotask runs — so the setTimeout callback never gets a turn. This is microtask starvation: an infinite chain of microtasks prevents all macrotasks (rendering, I/O, timers) from running. In a real browser, this freezes the page.