Uitdaging: plannen met Promises

"Plannen" betekent beslissen hoe een lijst met asynchrone taken moet worden uitgevoerd: allemaal samen, één voor één, of in kleine groepen. We combineren Promise.all, for await en sluitingen.

Parallel: allemaal samen

Wanneer taken onafhankelijk en snel zijn, start u ze allemaal en wacht u met Promise.all:

async function inParallelo(tasks) {
  return Promise.all(tasks.map((t) => t()));
}

const risultati = await inParallelo([
  () => Promise.resolve(1),
  () => Promise.resolve(2),
  () => Promise.resolve(3),
]);
// [1, 2, 3]

Totale tijd ≈ tijd van de langzaamste taak.

In serie: één voor één

Wanneer elke taak afhankelijk is van de vorige, of als u een snelheidslimiet wilt instellen:

async function inSerie(tasks) {
  const risultati = [];
  for (const t of tasks) {
    risultati.push(await t());
  }
  return risultati;
}

Totale tijd ≈ som van de tijden.

Met een gelijktijdigheidslimiet

Soms wil je geen duizend gelijktijdige aanvragen, maar wil je er ook niet op wachten serie ofwel: je wilt een maximaal N tijdens de vlucht.

async function conLimite(tasks, n) {
  const risultati = new Array(tasks.length);
  let i = 0;
  async function worker() {
    while (i < tasks.length) {
      const mio = i++;
      risultati[mio] = await tasks[mio]();
    }
  }
  await Promise.all(Array.from({ length: n }, worker));
  return risultati;
}

Het idee: je lanceert n "werkers" die de volgende index pakken totdat er niets meer over is.

Probeer het

Oefening beoordelen