What Are Promises in JavaScript?

What Are Promises in JavaScript?

A promise is an object representing the eventual result of an async operation. It is a placeholder for a value that will be available in the future.

The Three States

1. Pending: initial state, neither fulfilled nor rejected.
2. Fulfilled: the operation succeeded; the promise has a value.
3. Rejected: the operation failed; the promise has a reason (error).

A promise is pending when created. It transitions to fulfilled or rejected once (settled). It cannot change state after settling.

Basic Usage

const promise = fetch("/api");
promise
  .then((response) => response.json())
  .then((data) => console.log(data))
  .catch((err) => console.error(err))
  .finally(() => console.log("done"));
``
- `.then(onFulfilled)`: runs when the promise fulfills. Returns a new promise.
- `.catch(onRejected)`: runs when the promise rejects (or a .then throws).
- `.finally(onSettled)`: runs when the promise settles (fulfilled or rejected).

### Creating a Promise

```js
const promise = new Promise((resolve, reject) => {
  setTimeout(() => {
    if (success) resolve("data");
    else reject(new Error("failed"));
  }, 1000);
});
``
The executor function (`(resolve, reject) => {}`) runs immediately. Call `resolve(value)` to fulfill, `reject(reason)` to reject.

### Why Promises Replaced Callbacks

- **Once-only**: a promise settles exactly once (no inversion of control).
- **Chaining**: `.then` returns a new promise, enabling flat chains.
- **Single error handler**: one `.catch` handles errors from anywhere in the chain.
- **Parallel**: `Promise.all`, `Promise.race`, `Promise.allSettled`.
- **Async/await**: built on promises, makes code look synchronous.

### The Takeaway

A promise is a placeholder for a future value. It has three states: pending, fulfilled, rejected. It settles once. Use `.then`/`.catch`/`.finally` to handle the result. Create with `new Promise((resolve, reject) => {})`. Promises replaced callbacks for async flow because of once-only settlement, flat chaining, single error handling, and parallel utilities.