Gyakorlati feladat: valósítson meg egy olyan függvényt, amely egy URL-tömböt és egy párhuzamos kéréslimitet fogad, és fetch-kéréseket hajt végre a párhuzamos végrehajtás korlátozásával (legfeljebb limit kérés egyszerre), és az eredményeket az eredeti sorrendben adja vissza.

A problémát, amely a párhuzamos fetch-kérések számának korlátozásával kapcsolatos, úgy oldhatjuk meg, hogy sorba tesszük a kéréseket, és ellenőrizzük az aktív ígéretek számát. Az alábbiakban egy példát mutatunk be JavaScript-ben, async/await használatával:

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()) // vagy res.json() a feladattól függően
          .then(data => {
            results[index] = data;
          })
          .catch(err => {
            results[index] = err;
          })
          .finally(() => {
            activeCount--;
            next();
          });
      }
    }

    next();
  });
}

Ebben a kódban nem indítunk egyszerre több mint limit kérést, és minden befejezett kérés után elindítjuk a következőt a sorban. Az eredmények a results tömbben kerülnek tárolásra az eredeti sorrendben.