Asynchronous JavaScript

async/await is syntactic sugar over promises. An async function always returns a promise. await pauses the function until the awaited promise settles, then resumes with its fulfilled value or throws its rejection reason. This lets you write async code that reads top-to-bottom like synchronous code, without .then() chains.

A promise is an object representing the eventual result of an async operation. It is pending until it settles, then either fulfilled (with a value) or rejected (with a reason). It settles once and is then immutable. .then() registers a fulfillment handler, .catch() a rejection handler, and .finally() runs either way.

A callback is a function passed as an argument to be invoked later, typically when an async operation finishes. callback hell (the pyramid of doom) is when callbacks are nested inside callbacks to sequence dependent async steps, producing deeply indented, hard-to-read, error-prone code. Promises and async/await flatten that nesting.

An async function always returns a promise: a returned value fulfills it, a thrown error rejects it. At await, the function suspends and returns control to the caller; when the awaited promise settles, the continuation is scheduled as a microtask and resumes there with the value (or throws the reason). So code after await never runs synchronously — it runs on the microtask queue after the current task.

A rejected awaited promise throws at the await point, so you catch it with a normal try/catch; a synchronous throw inside an async function instead rejects its returned promise. Errors are swallowed when you forget to await or attach a .catch() — the rejection goes unhandled. The fix is to always await or chain .catch() on every promise.

Each .then() returns a new promise, so you can chain .then().then() to sequence async steps as a flat list instead of nested callbacks. If a handler returns a promise, the chain waits for it and adopts its result (flattening), passing the value to the next .then(). One trailing .catch() handles any rejection in the chain, replacing scattered per-callback error handling.

An observable is a lazy, push-based stream that can emit 0 to many values over time, plus an optional completion or error signal. Nothing runs until you subscribe; each subscription starts its own producer, and you get back a way to unsubscribe so the source can be cancelled and torn down.

A promise is eager (it runs at creation), settles once with a single value, and cannot be cancelled. An observable is lazy (runs on subscribe), can push 0 to many values over time, and is cancelable via unsubscribe. Promises always resolve asynchronously on the microtask queue; observables may emit synchronously or asynchronously.

All take an iterable of promises. Promise.all fulfills with an array of all values but rejects on the first rejection (fail-fast). Promise.race settles as soon as the first one settles, fulfilled or rejected. Promise.allSettled waits for all and yields a {status, value/reason} array, never rejecting. Promise.any fulfills with the first fulfillment, rejecting with an AggregateError only if all reject.

Awaiting in a loop runs steps sequentially — fine only when each depends on the previous. For independent work, start all promises first and await Promise.all([...]) to run them in parallel; note Promise.all is fail-fast, so use allSettled if you need every result. For many tasks, run a bounded pool (e.g. N workers pulling from a queue) so you exploit parallelism without overwhelming the resource.

There is no reliable instanceof Promise across realms, so the spec uses duck-typing: a value is treated as thenable if it is a non-null object (or function) whose .then is callable. Promise.resolve(x) relies on this — if x is already thenable it adopts its eventual state, otherwise it wraps x in a fulfilled promise.

A thenable is any object with a callable .then(resolve, reject) method. When you await a thenable or pass it to a promise resolution, the runtime calls its .then, adopting whatever it eventually signals — so a custom thenable can stand in for a real promise. This assimilation is recursive: a thenable resolving to another thenable keeps unwrapping until a non-thenable value remains.