Promise Combinators (all, allSettled, race, any)

Comprehensive Comparison of the 4 Promise Combinators

JavaScript provides four distinct static methods on Promise for coordinating concurrent operations:

The Empty Iterable ([]) Trap

Interviewers love testing empty array inputs because the four methods exhibit sharply contrasting behaviors:

1. Promise.all([]): Immediately fulfills with [] (synchronous tick microtask).
2. Promise.allSettled([]): Immediately fulfills with [].
3. Promise.race([]): Remains pending forever! Since there are no promises to settle, the race has no contenders and never completes.
4. Promise.any([]): Immediately rejects with AggregateError: All promises were rejected.

Polyfill Implementation: Promise.all

function promiseAll(iterable) {
  return new Promise((resolve, reject) => {
    const items = Array.from(iterable);
    if (items.length === 0) return resolve([]);

    const results = new Array(items.length);
    let completed = 0;

    items.forEach((item, index) => {
      // Wrap item with Promise.resolve to handle non-promise primitives
      Promise.resolve(item).then(
        (value) => {
          // Store at original index to preserve input order!
          results[index] = value;
          completed++;
          if (completed === items.length) {
            resolve(results);
          }
        },
        (err) => {
          // Fast fail on first rejection
          reject(err);
        }
      );
    });
  });
}

When to Use Which Combinator

• Use Promise.all when operations depend on one another (e.g. fetching user data AND authorization token before rendering).
• Use Promise.allSettled when tasks are independent and partial success is acceptable (e.g. bulk email sending or dashboard widgets where failed widgets render an error state without breaking the page).
• Use Promise.race for timeouts (e.g. Promise.race([fetchData(), timeout(5000)])).
• Use Promise.any for redundant mirrors or CDNs (fetch from 3 CDNs simultaneously, use whichever responds first successfully).