Implement Promise.all, Promise.allSettled, and Promise.race

Promise.all, Promise.allSettled, and Promise.race are static combinators that take an iterable of promises and return a single new promise. They differ in when that promise settles and what it settles with: all waits for every promise but fails fast on the first rejection, allSettled waits for every promise and never rejects, and race settles as soon as the first promise settles either way.

Implementing them is a great test of how well you can coordinate multiple async results with a counter and an index. The snippet below shows the behaviour we are reproducing so the differences between the three are concrete before we write any code.

const tasks = [Promise.resolve(1), Promise.resolve(2), Promise.reject("x")];

Promise.all(tasks).catch((err) => console.log(err)); // "x" — fails fast
Promise.allSettled(tasks).then((r) => console.log(r)); // array of {status,...}
Promise.race(tasks).then((v) => console.log(v)); // 1 — first to settle

All three accept the same input and return a single promise — the distinction is purely in their settling rules. This table is worth committing to memory, because interviewers often ask you to compare them before writing any code.

The challenge with all is preserving result order even though promises settle at different times. We solve it by writing each result into the array at its original index and tracking a counter of how many have completed. We resolve only when the counter hits the total, and reject immediately on the first failure. Watch the index capture inside the loop — that is what keeps results ordered.

function myAll(promises) {
  return new Promise((resolve, reject) => {
    const results = [];
    let completed = 0;
    const items = [...promises];

    if (items.length === 0) return resolve(results); // empty resolves now

    items.forEach((promise, index) => {
      // wrap with resolve so plain (non-promise) values work too
      Promise.resolve(promise).then(
        (value) => {
          results[index] = value; // preserve original order
          completed += 1;
          if (completed === items.length) resolve(results);
        },
        (reason) => reject(reason) // first rejection wins
      );
    });
  });
}

allSettled never rejects — it reports the outcome of every promise instead. So both the success and failure branches write a descriptive object into the results array and bump the same counter. The shape of those objects ({ status: 'fulfilled', value } or { status: 'rejected', reason }) matches the spec, which interviewers like to see you reproduce precisely.

function myAllSettled(promises) {
  return new Promise((resolve) => {
    const results = [];
    let completed = 0;
    const items = [...promises];

    if (items.length === 0) return resolve(results);

    items.forEach((promise, index) => {
      Promise.resolve(promise).then(
        (value) => {
          results[index] = { status: "fulfilled", value };
          completed += 1;
          if (completed === items.length) resolve(results);
        },
        (reason) => {
          results[index] = { status: "rejected", reason };
          completed += 1;
          if (completed === items.length) resolve(results);
        }
      );
    });
  });
}

Notice there is no reject call anywhere in this implementation — that is the defining feature of allSettled. A rejected input promise simply produces a { status: 'rejected', reason } entry instead of tearing down the whole operation, which is why it is the right choice when you want every result regardless of individual failures.

race is the simplest of the three. Because a promise can only settle once, we can attach resolve and reject directly to every input promise and let the first one to finish win — all later settlements are ignored automatically by the one-way nature of promises. No counter is needed.

function myRace(promises) {
  return new Promise((resolve, reject) => {
    // whichever settles first wins; the rest are ignored
    for (const promise of promises) {
      Promise.resolve(promise).then(resolve, reject);
    }
  });
}

These combinators show up constantly in real code — running requests in parallel, waiting for several resources, or timing out the slowest call. Implementing them proves you can coordinate concurrent async work, preserve ordering, and reason about settling semantics. Being able to explain why allSettled never rejects and why race needs no counter signals genuine command of the async model.