Promise.any — JavaScript Challenge | FineFrontend

Practice workspaceSign in

JavaScript/Promise.anymedium

00:00

Read here. Code on desktop. The coding workspace opens on screens 1024px and wider.

JavaScript interview question

Promise.any

medium20 min

Implement promiseAny(iterable), a standalone version of Promise.any. Return a Promise that fulfills with the first input to fulfill. Individual rejections do not end the operation: reject only when every input rejects, using an AggregateError whose errors array follows input order. Accept ordinary values, Promises, and thenables from any synchronous iterable.

Requirements

Export a named function promiseAny from the entry file. Do not replace or mutate the global Promise constructor.
Return a new native Promise. Fulfill with the value of the first fulfilled input; ignore individual rejections while another input could still fulfill.
If every input rejects, reject with an AggregateError. Preserve each original reason in its errors array in iterable order, including undefined and object identities. The error message is not prescribed.
An empty iterable must produce a rejected Promise with AggregateError.errors equal to an empty array.
Accept synchronous iterables such as arrays, Sets, strings, and generators. Normalize plain values and nested thenables using native Promise.resolve.
Consume the iterable synchronously and attach both settlement handlers to every input. An invalid iterable or a thrown iterator error must reject the returned Promise with the original error; it must not throw from the function call.
Do not mutate the input. Promise handlers must run asynchronously, as native Promise handlers do.
Use the native Promise constructor, Promise.resolve, and then/catch if useful. Do not call Promise.all, Promise.allSettled, Promise.any, or Promise.race to implement the function.
Promise subclass constructors, custom species, and full variadic tuple type inference are outside scope. The TypeScript signature may use one common generic value type.

Examples

Example 1

Input: await promiseAny([Promise.reject("unavailable"), Promise.resolve("ready")])
Output: "ready"

Example 2

Input: await promiseAny([0, Promise.resolve(2)])
Output: 0

Example 3

Input: promiseAny([Promise.reject("first"), Promise.reject("second")]).catch((error) => error.errors)
Output: ["first", "second"]

Example 4

Input: promiseAny([]).catch((error) => error.errors)
Output: []

promiseAny(iterable) returns a Promise for the first fulfilled value, or rejects with an AggregateError if all inputs reject. Examples show awaited values or caught errors rather than the Promise object itself.

What the tests check

Returns a new Promise for each call
Fulfills with the first plain value, including falsy values
Uses iterable order for already fulfilled promises
Uses fulfillment time rather than input position
Ignores earlier rejections while a fulfillment can still win
Rejects all-rejected inputs with AggregateError
Preserves rejection reasons in input order, not settlement order
Retains original rejection values and object identities
Rejects an empty iterable with an empty AggregateError errors array
Accepts a Set of inputs
Accepts a generator without array-specific methods
Adopts nested thenables
Counts a rejecting thenable as a rejection
Treats a throwing then getter as one rejected input
Accepts only the first settlement of a hostile thenable
Rejects with the original iterator error even after yielding a value
Rejects invalid input with TypeError without throwing synchronously
Does not mutate the input array
Keeps the result pending while one input remains pending and others reject
Runs fulfillment handlers asynchronously

References

ECMAScript specification: Promise.any MDN: Promise.any()

JavaScriptPromisesAsynchronous ProgrammingPromise settlementIterablesThenable assimilationError handling

Back

Preparing your workspace…