What is a Promise and what states does it have?

Question

IT Interview Practice · Accepted Answer

A **Promise** is an object representing a value that may not be available yet — the eventual result of an asynchronous operation. It has three states:

- **pending** — initial, not settled yet.
- **fulfilled** — completed successfully (has a value).
- **rejected** — failed (has a reason/error).

Once it settles (fulfilled or rejected) it's **immutable** — it can't change again.

```js
fetch("/api/user")
  .then(res => res.json())     // runs on fulfillment; return value flows down
  .then(user => render(user))
  .catch(err => showError(err)) // runs on ANY rejection in the chain
  .finally(() => hideSpinner()); // always runs
```

## Chaining flattens nested async

Returning a promise inside `.then` waits for it before continuing, so you avoid deeply nested callbacks ("callback hell"):

```js
getUser(id)
  .then(user => getPosts(user.id)) // returns a promise → chain waits for it
  .then(posts => console.log(posts));
```

## Combinators for multiple promises

```js
Promise.all([a, b, c]);     // wait for ALL; rejects fast if any fails
Promise.allSettled([a, b]); // wait for all, get each result/error
Promise.race([a, b]);       // settles with the FIRST to settle
Promise.any([a, b]);        // first to FULFILL (ignores rejections)
```

## Why it matters

Promises are the foundation of async JS — they replaced callback nesting, give unified error handling via `.catch`, and `async/await` is just nicer syntax on top of them.

Forgetting `.catch` (an unhandled rejection) is a common bug.

Chaining flattens nested async

Combinators for multiple promises

Why it matters

Related questions