Durante la chiamata
Dopo la chiamata
Per tipo di chiamata
Scopri
Fiducia
Sayli per i colloqui di lavoro
Porta i tuoi progetti. Spiega il tuo ragionamento, anche alle domande più difficili.
Esempi del prodotto in inglese.
![Technical interview: Senior engineer. Daniel Novak asks: Implement an async map with a concurrency limit. Preserve input order, stop scheduling on failure, and support cancellation. Sayli: Use a shared index and a fixed pool of workers. Each worker claims its index before awaiting, so two workers cannot claim the same item.
```ts
async function mapLimit<T, R>(
items: readonly T[],
limit: number,
run: (item: T, signal?: AbortSignal) => Promise<R>,
signal?: AbortSignal,
): Promise<R[]> {
if (!Number.isInteger(limit) || limit < 1)
throw new RangeError('limit must be a positive integer');
signal?.throwIfAborted();
const results = new Array<R>(items.length);
let next = 0;
let failed = false;
async function worker() {
while (!failed) {
signal?.throwIfAborted();
const i = next++;
if (i >= items.length) return;
try {
results[i] = await run(items[i], signal);
} catch (error) {
failed = true;
throw error;
}
}
}
await Promise.all(Array.from(
{ length: Math.min(limit, items.length) }, worker,
));
return results;
}
```
**Why it works:** results are written by input index, not completion order. At most `limit` calls are in flight. A rejection stops new work; already-running tasks finish unless their implementation honours the abort signal.
**Edge cases:** empty input, a limit larger than the input, out-of-order completion, a rejected task, and cancellation before or during the call. Time is O(n) bookkeeping plus the async work; result storage is O(n).](/media/hero-mobile/interviews-320.webp)
Use a shared index and a fixed pool of workers. Each worker claims its index before awaiting, so two workers cannot claim the same item.
async function mapLimit<T, R>(
items: readonly T[],
limit: number,
run: (item: T, signal?: AbortSignal) => Promise<R>,
signal?: AbortSignal,
): Promise<R[]> {
if (!Number.isInteger(limit) || limit < 1)
throw new RangeError('limit must be a positive integer');
signal?.throwIfAborted();
const results = new Array<R>(items.length);
let next = 0;
let failed = false;
async function worker() {
while (!failed) {
signal?.throwIfAborted();
const i = next++;
if (i >= items.length) return;
try {
results[i] = await run(items[i], signal);
} catch (error) {
failed = true;
throw error;
}
}
}
await Promise.all(Array.from(
{ length: Math.min(limit, items.length) }, worker,
));
return results;
}Why it works: results are written by input index, not completion order. At most limit calls are in flight. A rejection stops new work; already-running tasks finish unless their implementation honours the abort signal.
Edge cases: empty input, a limit larger than the input, out-of-order completion, a rejected task, and cancellation before or during the call. Time is O(n) bookkeeping plus the async work; result storage is O(n).
Conserva domande, risposte e ciò che devi preparare.
Conserva le decisioni. Ricorda i tuoi impegni.
Technical interview: Senior engineer. Daniel asked for an async map with a concurrency limit. You discussed keeping results in input order, stopping new work on failure and passing cancellation to each operation. Next steps: Practise the failure and cancellation walkthrough, You, Thu. Prepare tests for out-of-order results, You, Thu.
Inizia gratis. Il tuo contesto, quando serve.
Daniel Novak