Promises and Async/Await

A throw inside a .then callback rejects the promise that .then returned, so the chain skips every later fulfillment handler until it reaches a rejection handler — a .catch or a .then second argument — which receives the thrown value.

A promise is pending, fulfilled, or rejected. The first resolve() or reject() settles it permanently; every later call is silently ignored. So a promise that fulfilled can never become rejected, and its value can never change.

Every .then() call returns a brand-new promise. Returning a plain value from the callback fulfils that new promise with the value; returning a promise or thenable makes the new promise adopt that one's eventual outcome instead of nesting it.

A .catch handler that returns normally fulfills the promise .catch returned, with that return value. The chain is back on the success path: the next .then runs with whatever the handler returned, which is undefined if it returned nothing.

The callback never returns the promise from saveUser, so it returns undefined and the chain does not wait for the save. Fix it by returning the promise: user => saveUser(user), or add an explicit return inside the braces.

Promise.all rejects the moment any input promise rejects, and otherwise fulfils with an array of the values in input order. Promise.allSettled waits for every input and always fulfils, giving one {status, value or reason} object per entry.

All 5,000 requests start immediately: map calls fetch for every URL before Promise.all ever runs. Promise.all only observes promises that are already in flight, so any concurrency cap must be applied where the work is started.

Promise.race settles with the first input promise to settle and copies its outcome either way. If that first settled input rejects, the race rejects with the same reason, even when other inputs would have fulfilled.

Start exactly limit runner loops. Each pulls the next index from a shared cursor, awaits worker for that item, and writes the value into results[index] before pulling again. Awaiting all runners gives results in input order.

They keep running to completion. Promise.all's fail-fast rejection only settles the aggregate promise; it has no power to stop work already in flight, so the other uploads still finish, still write their side effects, and their outcomes are silently discarded.

An async function always returns a promise, never a raw value: return 42 fulfils that promise with 42, throw rejects it with the thrown error, and returning a promise makes the outer promise adopt that promise's eventual outcome.

await rethrows a rejected promise's reason as an ordinary exception at the await point, so a normal try/catch around that await catches it. The catch parameter is bound to whatever value the promise rejected with, which need not be an Error.

Awaiting inside the loop serializes the requests, so ten 200 ms calls take about 2 seconds. Start all ten promises first and await them together with Promise.all, and the whole batch takes roughly 200 ms.

The caller receives a pending promise straight away. The async function's frame is suspended, not blocked: its locals are parked, control returns to the caller, and the rest of the program keeps running until the awaited value settles and the function resumes.

Each await splits the function in two: the awaited expression becomes the promise you attach to, and everything after it becomes the callback. So load becomes fetchUser(id).then(user => fetchPosts(user.id).then(posts => ({ user, posts }))).

async function* combines await and yield in one body: the function can wait for asynchronous work and then emit a value, repeatedly. Calling next() on the object it returns gives a Promise that fulfils with {value, done}, not that record directly.

for await...of awaits every step of the iteration. It consumes async iterables (objects with a Symbol.asyncIterator method) and also ordinary iterables, awaiting each produced value before the body runs, so the body sees settled values instead of promises.

The error rejects the promise returned by the next() call that resumed the body, so a for await...of loop throws at that iteration. The generator then moves to the completed state permanently: later next() calls fulfil with {value: undefined, done: true} rather than rethrowing.

Declare it async function*, await each page inside the cursor loop, and yield the items instead of pushing them into an array. The caller then sees the first item before the last page is fetched and never holds the whole result set in memory.

It needs a Symbol.asyncIterator method returning an object with a next() that produces a promise of { value, done }. If only Symbol.iterator exists, the engine wraps that sync iterator and awaits each value; if neither exists, the loop throws a TypeError.

AbortController holds the trigger and exposes a read-only signal you hand to an operation. Calling controller.abort(reason) sets signal.aborted to true, stores signal.reason, and synchronously fires the signal's abort event, so any operation watching that signal can stop.

Call the original inside new Promise and translate its callback: reject(err) when the first argument is truthy, otherwise resolve(data). The executor runs immediately, must settle exactly once, and should contain nothing but that translation.

The await rejects after one second with the timer's error, but slowRequest() keeps running to completion and its result is simply discarded. Promise.race only reports the first settlement; it cannot stop or unsubscribe from the loser.

A floating promise is one whose result nobody awaits or attaches a handler to. If it rejects, the error never reaches the caller's try/catch: browsers fire an unhandledrejection event and log it, and Node terminates the process by default.

A promise is a read-only handle to a result that only its creator can settle, and any number of consumers may hold it, so no consumer can be allowed to cancel it. JavaScript therefore signals cancellation out-of-band with AbortController.