mitmario.dev

Mehrere Promises

JavaScript Im Browser 4 Min Lesezeit 3 BeispieleLektion 6 von 8

Drei Kacheln auf einer Startseite, und jede braucht 300 Millisekunden. Mit await in einer Schleife wartet jede auf die vorige, und am Ende dauert es dreimal so lange wie nötig. Dabei kannst du mehrere Dinge auch gleichzeitig anstoßen und dann auf alle zusammen warten.

Promise.all

Nacheinander gegen gleichzeitig
function laden(marke) {
  return new Promise((aufloesen) => {
    setTimeout(() => aufloesen(marke), 300);
  });
}

// Nacheinander: jedes await wartet auf das vorige.
async function nacheinander() {
  const start = Date.now();
  const a = await laden("a");
  const b = await laden("b");
  const c = await laden("c");
  console.log("nacheinander:", [a, b, c], Date.now() - start, "ms");
}

// Gleichzeitig: alle drei sind gestartet, BEVOR gewartet wird.
async function gleichzeitig() {
  const start = Date.now();
  const ergebnisse = await Promise.all([laden("a"), laden("b"), laden("c")]);
  console.log("gleichzeitig:", ergebnisse, Date.now() - start, "ms");
}

nacheinander().then(gleichzeitig);

Promise.all bekommt eine Liste von Promises und gibt ein einziges Promise zurück. Das löst auf, wenn alle aufgelöst haben, und liefert eine Liste der Ergebnisse. Zwei Eigenschaften davon zählen.

Die Ergebnisse stehen in der Reihenfolge der Liste und nicht in der Reihenfolge, in der sie fertig geworden sind. Antwortet das dritte zuerst, steht sein Ergebnis trotzdem an dritter Stelle, und deshalb kannst du direkt destrukturieren wie in Lektion 7.5.

Beim ersten Fehler bricht alles ab. Wird auch nur eines der Promises abgelehnt, wird das Gesamt-Promise sofort abgelehnt, mit genau diesem Grund. Die anderen laufen zwar zu Ende, aber ihre Ergebnisse siehst du nicht mehr.

Im ersten Beispiel steht der Unterschied in Zahlen. Dreimal 300 Millisekunden nacheinander sind rund 900, gleichzeitig sind es rund 300.

An der Zahl siehst du, dass es schneller ist. Warum, siehst du an einer Aufzeichnung im Reiter „Debug“, und zwar am Muster der Schritte. In der ersten Fassung wechseln sie sich ab, const a = await laden("a"), dann die zwei Zeilen aus laden, dann const b = await laden("b"), wieder die zwei Zeilen und dasselbe für c. Zwischen je zwei Aufrufen steht eine Zeile der wartenden Funktion, und dort ist sie zwischendurch weggegangen.

In der Fassung mit Promise.all steht eine Zeile mit dem await, und die zwei Zeilen aus laden kommen dreimal hintereinander, ohne dass etwas dazwischen liegt, marke=a, marke=b, marke=c. Zu diesem Zeitpunkt sind alle drei Timer schon angemeldet, und danach folgt genau eine Fortsetzung. Das ist der ganze Unterschied. Mit Geschwindigkeit hat er nichts zu tun, denn einmal wird dreimal hintereinander gewartet und einmal auf drei zugleich.

Promise.allSettled

all bricht ab, allSettled nicht
function laden(marke, scheitert) {
  return new Promise((aufloesen, ablehnen) => {
    setTimeout(() => {
      if (scheitert) {
        ablehnen(new Error(`${marke} nicht erreichbar`));
        return;
      }
      aufloesen(marke);
    }, 150);
  });
}

async function mitAll() {
  try {
    const alle = await Promise.all([
      laden("a", false),
      laden("b", true),
      laden("c", false),
    ]);
    console.log("all:", alle);
  } catch (fehler) {
    console.warn("all bricht beim ersten Fehler ab:", fehler.message);
  }
}

async function mitAllSettled() {
  const alle = await Promise.allSettled([
    laden("a", false),
    laden("b", true),
    laden("c", false),
  ]);
  console.log("allSettled roh:", alle);
  console.log(
    "allSettled ausgewertet:",
    alle.map((eintrag) => (eintrag.status === "fulfilled" ? eintrag.value : null))
  );
}

mitAll().then(mitAllSettled);

Promise.allSettled macht dasselbe, nur ohne das Abbrechen. Es wartet, bis alle fertig sind, egal wie sie ausgegangen sind, und wird selbst nie abgelehnt.

Dafür sehen die Ergebnisse anders aus. Statt der Werte kommt je Eintrag ein kleines Objekt.

  • Bei Erfolg steht status auf "fulfilled", und der Wert liegt in value.
  • Bei Ablehnung steht status auf "rejected", und der Grund liegt in reason.

Im zweiten Beispiel steht diese rohe Liste in der Console, und du kannst sie dort aufklappen. Erst {status: "fulfilled", value: "a"}, dann {status: "rejected", reason: Error: b nicht erreichbar}, dann wieder ein fulfilled. Darunter steht dieselbe Liste noch einmal, ausgewertet zu ["a", null, "c"]. Hinter einem allSettled steht deshalb fast immer ein map, das daraus wieder eine brauchbare Liste macht.

all passt, wenn ein Teilergebnis wertlos ist. Fehlt von drei Teilen einer Rechnung einer, soll keine falsche Summe dastehen. allSettled passt, wenn die Ansicht auch mit Lücken funktioniert. Acht Kacheln, von denen eine nicht laden konnte, sind besser als eine leere Seite.

race und any

Zwei weitere gibt es noch. Promise.race liefert das Ergebnis des ersten, das fertig wird, egal ob erfüllt oder abgelehnt. Typisch ist ein Zeitlimit. Die echte Anfrage tritt gegen einen Timer an, der nach fünf Sekunden ablehnt, und es zählt, was zuerst da ist.

Promise.any liefert das erste, das erfolgreich ist, und übergeht Ablehnungen, solange noch Hoffnung besteht. Das passt, wenn dieselbe Sache von mehreren Quellen kommen kann und du nur eine davon brauchst.

Beide kommen seltener vor als die ersten zwei.

Der Fehler, der alles wieder langsam macht

Der Fehler, der alles wieder langsam macht
function laden(marke) {
  return new Promise((aufloesen) => {
    setTimeout(() => aufloesen(marke), 300);
  });
}

// laden() wird sofort aufgerufen, und alle drei laufen.
async function richtig() {
  const start = Date.now();
  const aufgaben = [laden("a"), laden("b"), laden("c")];
  const alle = await Promise.all(aufgaben);
  console.log("richtig:", alle, Date.now() - start, "ms");
}

// Hier steht in der Liste je ein await, und damit ist die
// Reihe längst abgearbeitet, bevor Promise.all überhaupt
// etwas zu tun bekommt.
async function falsch() {
  const start = Date.now();
  const alle = await Promise.all([await laden("a"), await laden("b"), await laden("c")]);
  console.log("falsch:", alle, Date.now() - start, "ms");
}

richtig().then(falsch);

Die Aufrufe müssen gestartet sein, bevor gewartet wird. Ein Promise beginnt zu arbeiten, sobald es entsteht, und nicht erst beim await. Richtig ist deshalb, erst alle anzustoßen und dann auf die Liste zu warten.

Im dritten Beispiel steht in der falschen Fassung [await laden("a"), await laden("b"), await laden("c")] in der Klammer von Promise.all. Das sieht nach einer Liste aus. Gleichzeitig läuft dabei aber nichts. Jedes await hält an, bis es fertig ist, und wenn Promise.all die Liste bekommt, ist alles längst gelaufen. An der gemessenen Zeit siehst du es.

Hier stößt der Reiter „Debug“ an seine Grenze. In einer Aufzeichnung sehen beide Fassungen gleich aus, dreimal derselbe Rumpf hintereinander, obwohl die eine 300 Millisekunden braucht und die andere 900. Beide führen dieselben Anweisungen in derselben Reihenfolge aus. Was sie unterscheidet, sind die Pausen dazwischen, und die stehen nirgends, denn im Protokoll werden Schritte gezählt und keine Zeit. Im ersten Beispiel war der Unterschied sichtbar, weil dort jedes await eine eigene Zeile hatte. Hier stehen alle drei in einer.

Mit einer Schleife, in der await steht, passiert dasselbe. Sind die Durchläufe voneinander unabhängig, sammle ich die Promises ein und warte am Ende einmal auf alle.

Sehr viele Anfragen

Zweihundert Anfragen gleichzeitig loszuschicken ist selten eine gute Idee. Der Browser drosselt zwar selbst, aber der Server am anderen Ende freut sich trotzdem nicht.

Für solche Fälle arbeitet man in Blöcken, etwa zehn auf einmal. Dafür brauchst du keine Bibliothek, nur eine Schleife über Ausschnitte der Liste und je ein Promise.all darin. Für diesen Kurs ist das nicht nötig, nur ist „alle auf einmal“ eben nicht immer die beste Antwort.

In der Aufgabe lädst du drei Kacheln gleichzeitig, einmal ohne Ausfall und einmal mit einer, die scheitert.

Zum Mitnehmen

Promise.all wartet auf eine Liste von Promises und bricht beim ersten Fehler ab, allSettled wartet auf alle, wie auch immer sie ausgehen. Gleichzeitig laufen die Aufrufe nur, wenn alle schon gestartet sind, bevor das erste await kommt.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

Was in dieser Lektion steckt

  • Artikel mit 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe im Editor, direkt im Browser geprüft

    Öffnet sich mit dem Basis Konto.