Exercice pratique : implémentez une fonction qui prend un tableau d'URL et une limite de requêtes simultanées, et effectue des requêtes fetch avec une restriction d'exécution parallèle (pas plus de limit requêtes en même temps), en renvoyant les résultats dans l'ordre d'origine.

Pour résoudre le problème avec la limite du nombre de requêtes fetch simultanées, vous pouvez utiliser une file d'attente et contrôler le nombre de promesses actives. Voici un exemple d'implémentation en JavaScript utilisant 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()) // ou res.json() selon la tâche
          .then(data => {
            results[index] = data;
          })
          .catch(err => {
            results[index] = err;
          })
          .finally(() => {
            activeCount--;
            next();
          });
      }
    }

    next();
  });
}

Dans ce code, on ne lance pas plus de limit requêtes en même temps, et après chaque complétion, on en démarre une nouvelle dans la file d'attente. Les résultats sont stockés dans le tableau results dans l'ordre initial.