Map Async — JavaScript Challenge | FineFrontend

Practice workspaceSign in

JavaScript/Map Asyncmedium

00:00

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

JavaScript interview question

Map Async

medium20 min

Implement mapAsync(array, callback), an asynchronous mapping helper. Apply the callback to every item, start the mapping operations concurrently, and return a Promise containing their results in input order. Each callback may return an ordinary value, a Promise, or a thenable.

Requirements

Export mapAsync as the default export. It accepts an array and a mapping function and always returns a Promise.
Call callback(value, index, originalArray) exactly once for each item, in ascending index order. Pass the original array by reference. Input Promises are items themselves; do not automatically await them before invoking the callback.
Start all mapping operations without waiting for earlier operations to finish. A synchronous callback throw must not prevent later items from being started.
Fulfill with a new array of resolved callback results in original input order, regardless of completion order. Adopt Promises and thenables; preserve ordinary values and object identity. Do not flatten mapped arrays.
Reject with the first observed mapping rejection or synchronous callback error, preserving the exact reason. Do not wait for other pending mappings after a failure. Already started operations continue; this helper does not cancel them.
An empty array fulfills with a new empty array without invoking the callback.
Do not mutate the input array or its items. Assume callbacks do not mutate the input. Frozen arrays must be supported.
Reject non-array input or a non-function callback with TypeError through the returned Promise, including when the array is empty.
Native Array.map, Promise.all, and async/await are allowed. Dense arrays are in scope; sparse arrays, custom array subclasses, array-like objects, concurrency limits, cancellation, and retries are outside scope.

Examples

Example 1

Input: await mapAsync([1, 2, 3], async (value) => value * 2)
Output: [2, 4, 6]

Example 2

Input: await mapAsync(["a", "b"], (value, index) => `${index}: ${value.toUpperCase()}`)
Output: ["0: A", "1: B"]

Example 3

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

Example 4

Input: mapAsync([1, 2], async (value) => { if (value === 2) throw new Error("Unavailable"); return value; }).catch((error) => error.message)
Output: "Unavailable"

The examples show awaited results. Real API requests are unnecessary: tests use controlled asynchronous operations.

What the tests check

Returns a Promise containing asynchronous mapped values
Preserves input order when tasks finish in reverse order
Starts all mappings without waiting for earlier tasks
Supports a mapper that returns ordinary values
Supports mixed values, Promises, and thenables from the mapper
Passes the value, index, and original array to the mapper
Handles an empty array without calling the mapper
Preserves falsy mapped values and undefined returns
Produces a separate result array without mutating frozen input
Preserves object identity in mapped results
Invokes the mapper once per index, including duplicate items
Rejects with the original asynchronous error
Rejects without waiting for another pending mapping
Uses the first observed rejection rather than input position
Converts a synchronous mapper throw into a Promise rejection
Starts later mappings even when an earlier mapper throws
Adopts rejecting thenables and preserves rejection identity
Adopts nested thenables returned by the mapper
Rejects when reading a mapped thenable throws
Keeps nested array results as individual mapped values
Passes input Promises to the mapper without automatically awaiting them
Rejects non-array input with TypeError rather than throwing synchronously
Rejects invalid mappers, including for empty input
Runs result handlers asynchronously

References

MDN: Array.prototype.map()MDN: Promise.all()

JavaScriptPromisesArraysAsynchronous ProgrammingConcurrent mappingPromise aggregationCallback argumentsError handling

Back

Preparing your workspace…