Promise States: Pending, Fulfilled, Rejected in JavaScript

Promise States: Pending, Fulfilled, Rejected in JavaScript

A promise has three states. Understanding the transitions is essential for working with promises.

The States

1. Pending: the initial state. The promise is waiting for the async operation to complete.
2. Fulfilled: the operation succeeded. The promise has a value. resolve(value) was called.
3. Rejected: the operation failed. The promise has a reason (error). reject(reason) was called.

Transitions

pending -> fulfilled (resolve called)
pending -> rejected  (reject called)
``
A promise can only transition **once**. Once settled (fulfilled or rejected), it cannot change state.

```js
const p = new Promise((resolve, reject) => {
  resolve("first");  // fulfilled with "first"
  resolve("second"); // ignored (already settled)
  reject("error");   // ignored (already settled)
});
p.then((v) => console.log(v)); // "first"
``
### Checking State

There is no direct way to check a promise's state from outside (no `promise.state` property). You can only react to settlement via `.then`/`.catch`/`.finally`.

However, you can track it yourself:

```js
function track(promise) {
  let state = "pending";
  promise.then(() => { state = "fulfilled"; }, () => { state = "rejected"; });
  return () => state;
}
``
### Already Settled Promises

```js
Promise.resolve(42); // a promise fulfilled with 42
Promise.reject(new Error("oops")); // a promise rejected with an error
``
These are already settled. `.then`/`.catch` still run (as microtasks).

### The Takeaway

A promise starts pending, then transitions to fulfilled (`resolve`) or rejected (`reject`) once. It cannot change state after settling. `Promise.resolve` and `Promise.reject` create already-settled promises. There is no direct way to check state from outside; you react via `.then`/`.catch`.