Promise Output Challenges

Frequently asked questions

Why do promise-ordering questions come up so often?

Because they compress the whole asynchronous model into five lines. Getting one right means you know that the executor runs synchronously, that `.then` callbacks are microtasks, and that microtasks drain completely before the next macrotask — three facts that explain most real async bugs.

What is the single most common trap?

Assuming the executor is deferred. The function you pass to `new Promise` runs immediately and synchronously; only the callbacks are queued. A `console.log` inside the executor fires before anything after the constructor.

What does chaining actually return?

A new promise each time, which is why the value returned from one `.then` becomes the fulfilment value of the next, and why returning a promise from inside a `.then` waits for it rather than passing it along unwrapped. Most ordering surprises in longer chains come from that unwrapping step.

What else is worth knowing before answering these?

That a settled promise never changes — a `resolve` followed by a `reject` is ignored. That `.catch` is `.then(null, fn)`, so its position in the chain decides what it can catch. And that `async`/`await` is the same machinery, so an `await` is a `.then` for the purpose of working out ordering.