task-queue.ts en TypeScript

Una cola de tareas tipada que corre trabajos con concurrencia acotada.

#!/usr/bin/env node
// Una cola de tareas tipada que ejecuta trabajos con concurrencia limitada.

type Job<T> = () => Promise<T>;

interface Outcome<T> {
  index: number;
  value?: T;
  error?: string;
}

async function runPool<T>(
  jobs: Job<T>[],
  limit: number,
): Promise<Outcome<T>[]> {
  const results: Outcome<T>[] = [];
  let next = 0;

  async function worker(): Promise<void> {
    while (next < jobs.length) {
      const index = next++;
      try {
        results.push({ index, value: await jobs[index]() });
      } catch (error) {
        const message = error instanceof Error ? error.message : "unknown";
        results.push({ index, error: message });
      }
    }
  }

  const size = Math.min(limit, jobs.length);
  await Promise.all(Array.from({ length: size }, worker));
  return results.sort((a, b) => a.index - b.index);
}

const jobs: Job<string>[] = [1, 2, 3, 4, 5].map((n) => async () => {
  await new Promise((r) => setTimeout(r, n * 20));
  if (n === 3) throw new Error("job 3 failed");
  return `job ${n} done`;
});

const outcomes = await runPool(jobs, 2);
for (const outcome of outcomes) {
  console.log(outcome.error ? `x ${outcome.error}` : `. ${outcome.value}`);
}

Cómo funciona

1. Job<T> y Outcome<T> tipan el trabajo y los resultados.
2. Los workers toman el siguiente índice hasta vaciar la cola.
3. Las fallas se capturan por trabajo, no se descartan.

Palabras clave y builtins usados aquí

• Array
• Job
• Math
• Outcome
• Promise
• T
• async
• await
• catch
• const
• for
• from
• function
• if
• interface
• let
• message
• number
• of
• return
• size
• string
• throw
• try
• type
• while

El intento, en números

Líneas

45

Caracteres a escribir

1114

Tokens

344

Ritmo de tres estrellas

115 tpm

Al ritmo de tres estrellas de 115 tokens por minuto, este intento toma unos 179 segundos.

Escribe este fragmento

Paso 1 de 1 en Bis; paso 8 de 8 en Async y módulos.

← Anterior