Serielle und parallele Operationen in JavaScript

var Elemente = [ 1, 2, 3, 4, 5, 6 ];
var Ergebnisse = [];

Funktion async(Argument, Rückruf) {
  console.log('Parameter ist ' + arg +', gibt Ergebnis nach 1 Sekunde zurück');
  setTimeout(Funktion () { Rückruf(Argument * 2); }, 1000);
}

Funktion final(Wert) {
  console.log('Abgeschlossen: ', Wert);
}

Funktion Serie(Element) {
  wenn(Artikel) {
    async(Element, Funktion(Ergebnis) {
      Ergebnisse.push(Ergebnis);
      return series(items.shift()); // alle Daten rekursiv ausführen });
  } anders {
    return final(Ergebnisse[Ergebnisse.Länge - 1]);
  }
}

Serie (Elemente.Shift());

var Elemente = [ 1, 2, 3, 4, 5, 6 ];
var Ergebnisse = [];

Funktion async(Argument, Rückruf) {
  console.log('Parameter ist ' + arg +', gibt Ergebnis nach 1 Sekunde zurück');
  setTimeout(Funktion () { Rückruf(Argument * 2); }, 1000);
}

Funktion final(Wert) {
  console.log('Abgeschlossen: ', Wert);
}

items.forEach(Funktion(Element) {// Schleife abgeschlossen async(Element, Funktion(Ergebnis){
    Ergebnisse.push(Ergebnis);
    if(results.length === items.length) {// Bestimmen Sie, ob die Anzahl der abgeschlossenen Funktionen der Anzahl der auszuführenden Funktionen entspricht final(results[results.length - 1]);
    }
  })
});

var Elemente = [ 1, 2, 3, 4, 5, 6 ];
var Ergebnisse = [];
var läuft = 0;
Variablenlimit = 2;

Funktion async(Argument, Rückruf) {
  console.log('Parameter ist ' + arg +', gibt Ergebnis nach 1 Sekunde zurück');
  setTimeout(Funktion () { Rückruf(Argument * 2); }, 1000);
}

Funktion final(Wert) {
  console.log('Abgeschlossen: ', Wert);
}

Funktion Launcher() {
  während(läuft < Limit && Elemente.Länge > 0) {
    var item = items.shift();
    async(Element, Funktion(Ergebnis) {
      Ergebnisse.push(Ergebnis);
      läuft--;
      wenn (Elementlänge > 0) {
        Trägerrakete();
      } sonst wenn(läuft == 0) {
        endgültige(Ergebnisse);
      }
    });
    läuft++;
  }
}

Trägerrakete();

winziger asynchroner Pool, ES6-Promise-Pool, P-Limit

Funktion PromiseLimit(funcArray, limit = 5) { // 5 Daten gleichzeitig ausführen let i = 0;
  const Ergebnis = [];
  const wird ausgeführt = [];
  const Warteschlange = Funktion() {
    wenn (i === funcArray.length) return Promise.all(wird ausgeführt);
    const p = funcArray[i++]();
    Ergebnis.push(p);
    const e = p.then(() => ausführen.splice(ausführen.indexOf(e), 1));
    Ausführen von Push(e);
    wenn (Ausführungslänge >= Limit) {
      returniere Promise.race(Ausführen).dann(
        () => Warteschlange(),
        e => Versprechen.ablehnen(e)
      );
    }
    gibt Promise.resolve().then(() => queue()) zurück;
  };
  returniere queue().then(() => Promise.all(Ergebnis));
}

// Testcode const result = [];
für (let index = 0; index < 10; index++) {
  Ergebnis.push(Funktion() {
    returniere neues Promise((lösen, ablehnen) => {
      console.log("start" + index, neues Date().toLocaleString());
      setzeTimeout(() => {
        auflösen (Index);
        console.log("Ende" + index, neues Date().toLocaleString());
      }, parseInt(Math.random() * 10000));
    });
  });
}

PromiseLimit(Ergebnis).dann(Daten => {
  konsole.log(Daten);
});

// Ändern Sie den Testcode, sodass er nach dem Zufallsprinzip fehlschlägt oder erfolgreich ist const result = [];
für (let index = 0; index < 10; index++) {
  Ergebnis.push(Funktion() {
    returniere neues Promise((lösen, ablehnen) => {
      console.log("start" + index, neues Date().toLocaleString());
      setzeTimeout(() => {
        wenn (Math.random() > 0,5) {
          auflösen (Index);
        } anders {
          ablehnen(index);
        }
        console.log("Ende" + index, neues Date().toLocaleString());
      }, parseInt(Math.random() * 1000));
    });
  });
}
PromiseLimit(Ergebnis).dann(
  Daten => {
    console.log("Erfolg", Daten);
  },
  Daten => {
    console.log("fehlgeschlagen", Daten);
  }
);

asynchrone Funktion PromiseAll(promises,batchSize=10) {
 const Ergebnis = [];
 während(Versprechen.Länge > 0) {
   const data = warte auf Promise.all(promises.splice(0,batchSize));
   Ergebnis.push(...Daten);
 }
Ergebnis zurückgeben;
}

asynchrone Funktion asyncPool(Array,PoolLimit,IteratorFn) {
  Konstanten ret = [];
  const wird ausgeführt = [];
  für (const Element des Arrays) {
    const p = Promise.resolve().then(() => iteratorFn(item, array));
    ret.push(p);

    wenn (PoolLimit <= Array.Länge) {
      const e = p.then(() => ausführen.splice(ausführen.indexOf(e), 1));
      Ausführen von Push(e);
      wenn (Ausführungslänge >= PoolLimit) {
        warte auf Promise.race (Ausführung);
      }
    }
  }
  gibt Promise.all(ret) zurück;
}

const timeout = i => neues Versprechen(auflösen => setTimeout(() => auflösen(i), i));
return asyncPool( [1000, 5000, 3000, 2000], 2,timeout).dann(Ergebnisse => {
    ...
});