Durante la llamada
Después de la llamada
Por conversación
Aprende
Confianza
Sayli para entrevistas de trabajo
Trae tus proyectos. Explica cómo piensas, incluso ante preguntas difíciles.
Ejemplos del producto en inglés.
![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).
Guarda las preguntas, tus respuestas y lo que debes preparar.
Guarda las decisiones. Recuerda tus compromisos.
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.
Empieza gratis. Tu contexto, cuando lo necesites.
Daniel Novak