Map Async Limit — JavaScript Challenge | FineFrontend

Practice workspaceSign in

JavaScript/Map Async Limitmedium

00:00

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

JavaScript interview question

Map Async Limit

medium20 min

Implement mapAsyncLimit(items, mapper, limit). Map every item using a possibly asynchronous callback while allowing at most limit calls to be in flight at once. Start another item as soon as a slot becomes free, and return results in input order even when tasks finish out of order.

Requirements

Export mapAsyncLimit as both a named and default export. Return a Promise resolving to a new array of mapped values.
Call mapper(item, index) exactly once per item on success. Accept synchronous values, promises, and thenables; await each result before freeing its slot.
Never exceed the positive integer concurrency limit. Refill available slots as tasks finish; do not process rigid batches.
Preserve result order by input position. Do not mutate the input array. An empty array resolves to [] without calling mapper.
Reject with a RangeError for a non-positive, fractional, non-finite, or missing limit, even for empty input; return a rejected Promise rather than throwing synchronously.
If mapper throws or rejects, reject with that exact reason. Stop scheduling new items once failure is observed. Already started work may finish and must not cause unhandled rejections.
Inputs are dense arrays; mapper is callable. External cancellation, retries, and sparse arrays are outside this question. TypeScript accepts readonly input arrays and infers the resolved result type.

Examples

Example 1

Input: await mapAsyncLimit([1, 2, 3], async (value) => value * 2, 2)
Output: [2, 4, 6], with at most two callbacks in flight

Example 2

Input: await mapAsyncLimit(["a", "b"], (value, index) => value + index, 1)
Output: ["a0", "b1"]

Example 3

Input: await mapAsyncLimit([], async (value) => value, 3)
Output: []

mapAsyncLimit<T, U>(items: readonly T[], mapper: (item: T, index: number) => U | PromiseLike<U>, limit: number): Promise<U[]>

What the tests check

Maps asynchronous values
Supports synchronous mapper returns
Supports thenables
Empty input does not invoke the mapper
Passes each item and its original index exactly once
Does not mutate frozen input
Preserves result order when tasks finish out of order
Starts only as many pending tasks as the limit
Refills a freed slot without waiting for the whole batch
Limit one runs tasks sequentially
Limits larger than the input are supported
Rejects invalid limits asynchronously
Rejects with the original synchronous error
Rejects with the original asynchronous reason
Stops new work once failure is observed and handles later failures
Returns original object references from the mapper

References

Promise resolution Promise.all()

PromisesArraysConcurrencyWorker schedulingError handlingResult ordering

Back

Preparing your workspace…