Implement Promise.any() with AggregateError

Q: Implement Promise.any() with AggregateError

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Medium > **How to read this doc:** the real, defining difference from `Promise.race` this question tests — that an EARLIER rejection must be correctly IGNORED if a later promise still fulfills — was verified directly: with input `[rejectedPromise, fastFulfillment, slowFulfillment]`, the result correctly resolved with the fast fulfillment's value, never short-circuiting on the earlier rejection. ## 1. The problem, restated Given an iterable of promises, resolve with the value of whichever one fulfills FIRST — genuinely, completely ignoring any rejections along the way, UNLESS every single promise rejects, in which case reject with a real `AggregateError` containing every individual rejection reason, in their original input order. ## 2. Clarifying questions a strong candidate asks | Question | Why it matters | | :--- | :--- | | Different from Promise.race? | Yes, genuinely, criticall

The problem

Problem, as an interviewer would state it: "Implement Promise.any(promises) — resolving with the value of the FIRST promise to fulfill, and REJECTING with a real AggregateError (containing every individual rejection reason) only if EVERY promise rejects, matching real native Promise.any's own documented contract."

Examples:

Code

Promise.any([Promise.reject("x"), Promise.resolve("y")]); // resolves "y"
Promise.any([Promise.reject("a"), Promise.reject("b")]);  // rejects AggregateError

Clarifying questions expected:

How does this genuinely differ from Promise.race — does an EARLIER rejection need to be correctly ignored if a LATER promise still fulfills?
What real, specific error type should be thrown when every promise rejects — a plain Error, or the real, dedicated AggregateError?
What is the real, correct behavior for a genuinely empty input array?

Code / implementation expected: Yes — real, direct proof it resolves on the first fulfillment despite an earlier rejection, and throws a real AggregateError (populated with every individual rejection reason) only when every promise genuinely rejects.

promise
promiseAny
aggregateError

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for practical JavaScript coding interviews. Difficulty: Medium

How to read this doc: the real, defining difference from Promise.race this question tests — that an EARLIER rejection must be correctly IGNORED if a later promise still fulfills — was verified directly: with input [rejectedPromise, fastFulfillment, slowFulfillment], the result correctly resolved with the fast fulfillment's value, never short-circuiting on the earlier rejection.

1. The problem, restated

Given an iterable of promises, resolve with the value of whichever one fulfills FIRST — genuinely, completely ignoring any rejections along the way, UNLESS every single promise rejects, in which case reject with a real AggregateError containing every individual rejection reason, in their original input order.

2. Clarifying questions a strong candidate asks

| Qu

The solution is hidden so you can try first

6 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, direct proof: the Promise.any polyfill resolves on the first fulfillment despite an earlier rejection, and correctly throws a real AggregateError when every promise rejects