Praktische taak: implementeer een functie die een array van URL's en een limiet voor gelijktijdige verzoeken accepteert, en voer fetch-verzoeken uit met beperking van parallelle uitvoering (niet meer dan limit verzoeken tegelijk), en retourneer de resultaten in de oorspronkelijke volgorde.

Om het probleem met de beperking van het aantal gelijktijdige fetch-verzoeken op te lossen, kun je een wachtrij gebruiken en het aantal actieve promises controleren. Hier is een voorbeeldimplementatie in JavaScript met async/await:

async function limitedFetch(urls, limit) {
  const results = new Array(urls.length);
  let activeCount = 0;
  let currentIndex = 0;

  return new Promise((resolve, reject) => {
    function next() {
      if (currentIndex === urls.length && activeCount === 0) {
        resolve(results);
        return;
      }

      while (activeCount < limit && currentIndex < urls.length) {
        const index = currentIndex++;
        activeCount++;
        fetch(urls[index])
          .then(res => res.text()) // of res.json() afhankelijk van de taak
          .then(data => {
            results[index] = data;
          })
          .catch(err => {
            results[index] = err;
          })
          .finally(() => {
            activeCount--;
            next();
          });
      }
    }

    next();
  });
}

In dit script worden niet meer dan limit verzoeken gelijktijdig gestart, en na elk voltooid verzoek wordt de volgende uit de wachtrij gestart. De resultaten worden opgeslagen in het array results in de oorspronkelijke volgorde.