Praktische Aufgabe: Implementieren Sie eine Funktion, die ein Array von URLs und ein Limit für gleichzeitige Anfragen akzeptiert, und führt fetch-Anfragen mit Begrenzung der parallelen Ausführung durch (nicht mehr als limit Anfragen gleichzeitig), wobei die Ergebnisse in der ursprünglichen Reihenfolge zurückgegeben werden.

Um das Möglichkeiten, das Problem mit der Begrenzung der gleichzeitigen fetch-Anfragen zu lösen, ist die Verwendung einer Warteschlange und die Kontrolle der Anzahl der aktiven Promises. Hier ist ein Beispiel für eine Implementierung in JavaScript mit 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()) // oder res.json() je nach Aufgabe
          .then(data => {
            results[index] = data;
          })
          .catch(err => {
            results[index] = err;
          })
          .finally(() => {
            activeCount--;
            next();
          });
      }
    }

    next();
  });
}

In diesem Code starten wir nicht mehr als limit Anfragen gleichzeitig, und nach Abschluss jeder Anfrage starten wir die nächste in der Warteschlange. Die Ergebnisse werden im Array results in der ursprünglichen Reihenfolge gespeichert.