Promises

A Promise is an object representing the eventual result of an asynchronous operation — something that hasn't finished yet, but will finish (successfully or not) at some point in the future. Instead of forcing your code to freeze and wait, a Promise lets you keep going and attach instructions for what to do once the result is ready. This solves the exact problem from the previous lesson: it gives asynchronous work a proper, catchable way to report success or failure.

You create a Promise with the Promise constructor, which takes a single function called the executor. The executor receives two functions as arguments — resolve and reject — call resolve(value) when the operation succeeds, or reject(error) when it fails. Once a promise settles (resolves or rejects), its state is locked in permanently; it can never change again.

.then() registers callbacks to run when a promise fulfills (first argument) or rejects (second, optional argument). .catch() is shorthand for handling only the rejection case, and reads more cleanly when placed after one or more .then() calls. .finally() runs once the promise settles, regardless of whether it fulfilled or rejected — just like the finally block from try/catch, it's the place for cleanup that must always happen.

Each call to .then() returns a brand new promise, which is what makes chaining possible. If you return a plain value from inside a .then() callback, that value becomes the fulfillment value of the next promise in the chain. If you return another promise, the chain waits for that promise to settle before continuing — this is how you sequence multiple asynchronous steps, one after another, without nesting callbacks inside callbacks.

Promise.all() takes an array of promises and returns a single promise that fulfills with an array of all their results, in the same order, once every one of them has fulfilled. If even one of the promises rejects, Promise.all() immediately rejects with that error, without waiting for the others. It's the right tool when you need several independent operations to all succeed before moving on.

Promise.race() also takes an array of promises, but settles as soon as the first one settles — whether that first one fulfills or rejects. This is useful for scenarios like timeouts, where you want to race a real operation against a promise that rejects after a set duration, so a slow request doesn't hang forever.

Unlike Promise.all(), Promise.allSettled() never short-circuits on a rejection. It waits for every promise to settle and returns an array of result objects, each shaped like { status: 'fulfilled', value } or { status: 'rejected', reason }. Reach for this when you want to know the outcome of every operation — successes and failures alike — instead of stopping at the first failure.