Output Quiz #12 — Microtask Queue: Breadth-First Ordering

Output:

A
C
B
D

Why: At the end of synchronous code, the microtask queue has two entries: [cbA, cbC]. cbA runs → logs "A" → schedules cbB at the end of the queue. Queue: [cbC, cbB]. cbC runs → logs "C" → schedules cbD. Queue: [cbB, cbD]. cbB → "B"; cbD → "D". This is breadth-first interleaving — the chains alternate depth levels. Most developers expect "A B C D".

Output:

1
4
2
5
3

Why: Start: microtask queue [cb1, cb4]. cb1 runs → 1 → schedules cb2. Queue: [cb4, cb2]. cb4 runs → 4 → schedules cb5. Queue: [cb2, cb5]. cb2 runs → 2 → schedules cb3. Queue: [cb5, cb3]. cb5 → 5; cb3 → 3. Each depth level from each chain runs before the next level from any chain. 3 comes last even though it started first.

Output:

A
C
E
B
D
F

Why: Three chains, same rule. Microtask queue initially: [A, C, E]. A runs → schedules B. C runs → schedules D. E runs → schedules F. Queue: [B, D, F]. All three depth-1 callbacks run before any depth-2 callback. Breadth-first means each "round" of the microtask queue processes one .then() from each chain, then the next round, and so on.

Output:

A
B
C

Why: queueMicrotask and Promise.resolve().then() both schedule to the same microtask queue. They are ordered by insertion. "A" is queued first, then "B", then "C". So: A, B, C. There is no priority difference — the queue is a simple FIFO. Use either API, but be consistent in your mental model: they're the same thing.

Output:

A
C
B

Why: Microtask queue initially: [cbA, cbC]. cbA runs → logs "A" → queues qmB at the end. Queue: [cbC, qmB]. cbC runs → "C". Then qmB → "B". The queueMicrotask from inside a .then() doesn't jump ahead — it goes to the back of the current microtask queue and runs before the next macrotask, but after already-scheduled microtasks.

Output:

f1-sync
f2-sync
f3-sync
global
f1-end
f2-end
f3-end

Why: The pre-await code in each async function runs synchronously as part of the call. So f1-sync, f2-sync, f3-sync all run in order. Then "global". Each await null suspends and schedules its continuation as a microtask, in order: [f1-end, f2-end, f3-end]. Microtask drain: f1-end, f2-end, f3-end. Simple FIFO because each only has one await.

Output:

A1
B1
sync
A2
B2
A3

Why: Sync: A1, B1, "sync". First microtask round: [A2, B2]. A2 runs → schedules A3. B2 runs. Second microtask round: [A3]. A3 runs. So A2 runs before B2 (FIFO in round 1), but A3 is scheduled in round 2 and runs after B2. The second await creates a natural depth break — A3 goes one round deeper than A2.

Output:

1
2
3
timeout

Why: Microtask drains before the setTimeout macrotask. 1 logs, schedules microtask for 2. Microtask queue now: [log2]. 2 logs, schedules microtask for 3. Queue: [log3]. 3 logs. Queue now empty. Then — and only then — the setTimeout macrotask runs: "timeout". No matter how deep the nested microtask chain goes, all must drain before the next macrotask.

Output:

plain: 42
inner: inner
outer: inner

Why: resolve(42) is a plain value — the .then() is queued immediately. resolve(inner) triggers Promise adoption — the engine must call inner.then(resolveOuter, rejectOuter), which is itself a microtask.

Timeline:

1. Sync ends. Microtask queue: [adopt inner→outer, cb "plain: 42", cb "inner: inner"]
2. adopt runs → outer resolves → queues cb "outer: inner". Queue: [cb "plain: 42", cb "inner: inner", cb "outer: inner"]
3. "plain: 42" logs, then "inner: inner", then "outer: inner".

The extra adoption tick pushes outer's .then() one position later — behind inner's own .then() and behind the plain-value chain's .then().

Output:

A
D
SYNC
B
E
QM1
P1
QM2
C
T1

Why: Full tick-by-tick trace:

Sync: A, D, "SYNC". After sync:

• Microtask queue: [B, E, QM1, P1, QM2] — f1's first continuation, f2's continuation, then the three sync-scheduled microtasks in order.
• Macrotask queue: [T1]

Microtask drain — round 1:

• B runs → schedules C (new microtask). Queue: [E, QM1, P1, QM2, C]
• E runs. Queue: [QM1, P1, QM2, C]
• QM1 runs. Queue: [P1, QM2, C]
• P1 runs. Queue: [QM2, C]
• QM2 runs. Queue: [C]
• C runs. Queue empty.

Macrotask drain: T1.