//Implementeer de functie // promiseAllLimit(tasks: Array<() => Promise<unknown>>, limit: number): Promise<any[]>, //die promises uitvoert met een beperking op het maximale aantal gelijktijdige verzoeken.

De functie promiseAllLimit stelt je in staat om taken (functies die beloven te retourneren) uit te voeren met een beperking op het aantal gelijktijdige beloftes. Dit is handig, bijvoorbeeld, om het netwerk of de API niet te overbelasten.

Voorbeeld van implementatie:

function promiseAllLimit(tasks, limit) {
  return new Promise((resolve, reject) => {
    const results = [];
    let running = 0;
    let index = 0;
    let resolvedCount = 0;

    function runNext() {
      if (resolvedCount === tasks.length) {
        resolve(results);
        return;
      }

      while (running < limit && index < tasks.length) {
        const currentIndex = index;
        const task = tasks[currentIndex];
        index++;
        running++;

        task()
          .then(result => {
            results[currentIndex] = result;
          })
          .catch(err => {
            reject(err);
          })
          .finally(() => {
            running--;
            resolvedCount++;
            runNext();
          });
      }
    }

    runNext();
  });
}

Hier starten we tot limit taken tegelijk, en na elke voltooiing starten we de volgende, totdat alle taken verwerkt zijn. De resultaten worden opgeslagen in een array in de volgorde van de oorspronkelijke taken.