mitmario.dev

Callbacks und ihre Grenzen

JavaScript Im Browser 3 Min Lesezeit 3 BeispieleLektion 3 von 8

Der Code soll warten, bis ein Ergebnis da ist, und dann damit weitermachen. Dafür muss er eine Funktion hinterlegen, so viel ist seit der letzten Lektion klar. Der älteste Weg, das hinzuschreiben, kam in Lektion 5.7 schon vor, nämlich eine Funktion mitgeben, die später aufgerufen wird. Neu ist nur, was „später“ heißt. Bei map heißt es „gleich, für jeden Eintrag“, und hier heißt es „irgendwann, wenn das Ergebnis da ist“.

Das Fehler-zuerst-Muster

Das Fehler-zuerst-Muster
const lager = { a1: "Tastatur", b2: "Maus" };

// Die Verabredung: der Callback bekommt als ERSTES den
// Fehler, danach das Ergebnis. Genau einer von beiden ist
// gesetzt, der andere ist null.
function artikelLaden(id, zurueck) {
  setTimeout(() => {
    const name = lager[id];
    if (!name) {
      zurueck(new Error(`Nicht im Lager: ${id}`), null);
      return;
    }
    zurueck(null, name);
  }, 150);
}

artikelLaden("a1", (fehler, name) => {
  if (fehler) {
    console.error("Ging nicht:", fehler.message);
    return;
  }
  console.log("Gefunden:", name);
});

artikelLaden("zzz", (fehler, name) => {
  if (fehler) {
    console.error("Ging nicht:", fehler.message);
    return;
  }
  console.log("Gefunden:", name);
});

console.log("Beide Aufrufe sind abgeschickt.");

Wenn etwas asynchron schiefgehen kann, muss der Fehler denselben Weg nehmen wie das Ergebnis, also durch den Callback. Dafür gibt es eine Verabredung, die du überall wiedererkennst.

Der Callback bekommt zwei Argumente. Das erste ist der Fehler, das zweite das Ergebnis. Gesetzt ist immer genau eines von beiden, das andere ist null.

Deshalb prüft der Aufrufer immer zuerst den Fehler und steigt bei Bedarf sofort aus. Erst danach kommt der Teil, der mit dem Ergebnis arbeitet.

Die Reihenfolge wirkt willkürlich, hat aber einen Grund. Als erstes Argument steht der Fehler im Weg, und so übersieht man ihn kaum. In Node.js bekommen die meisten eingebauten Funktionen mit Callback bis heute als erstes Argument den Fehler, und deshalb zeigt dieser Kurs ein Muster, das du selbst kaum noch schreiben, aber garantiert lesen wirst.

Drei Schritte, drei Ebenen

Drei Schritte, drei Ebenen
const ausgabe = document.getElementById("ausgabe");

function schritt(marke, zurueck) {
  setTimeout(() => {
    console.log("fertig:", marke);
    zurueck(null, marke);
  }, 100);
}

// Jeder Schritt braucht das Ergebnis des vorigen. Deshalb
// muss er in dessen Callback hinein, und deshalb wandert
// der Code bei jedem Schritt weiter nach rechts.
schritt("Wasser kochen", (fehler1, wasser) => {
  if (fehler1) return;
  schritt("Tee ziehen lassen", (fehler2, tee) => {
    if (fehler2) return;
    schritt("einschenken", (fehler3, tasse) => {
      if (fehler3) return;
      ausgabe.textContent = `fertig: ${wasser}, ${tee}, ${tasse}`;
      console.log("Alle drei durch.");
    });
  });
});

Ein einzelner Callback ist harmlos. Unangenehm wird es, sobald ein Schritt auf dem Ergebnis des vorigen aufbaut.

Der zweite Schritt kann erst starten, wenn der erste fertig ist. Also muss sein Aufruf in den Callback des ersten hinein, und der dritte in den des zweiten. Schon steht der Code drei Ebenen weit rechts, mit drei Fehlerprüfungen, die alle dasselbe tun.

Bei fünf Schritten ist das ein Gebirge, und von weitem sieht es aus wie sein Name, Callback Hell. Das ist allerdings nur die Hälfte des Problems. Und zwar die harmlosere, denn Einrückung ist unangenehm zu lesen, mehr nicht.

Der eigentliche Grund für den Wechsel

Warum try/catch hier nichts fängt
function spaeterWerfen(zurueck) {
  setTimeout(() => {
    zurueck();
  }, 100);
}

try {
  spaeterWerfen(() => {
    console.log("Der Callback läuft jetzt.");
    throw new Error("Aus dem Callback geworfen");
  });
  console.log("Der try-Block ist hier schon zu Ende.");
} catch (fehler) {
  console.log("Dieses catch läuft nie:", fehler.message);
}

// Dass der Fehler trotzdem irgendwo landet, siehst du im
// Reiter "Console": als ungefangener Fehler, ohne jede
// Chance, ihn an der richtigen Stelle zu behandeln.

Ein Fehler in einem Callback lässt sich mit try/catch nicht fangen. Im dritten Beispiel steht der Aufruf im try-Block. Der Aufruf meldet einen Timer an und ist sofort fertig, der try-Block damit auch. Hundert Millisekunden später läuft der Callback, und von diesem try ist nichts mehr übrig. Der Fehler geht daran vorbei, und in der Console steht Uncaught Error: Aus dem Callback geworfen.

Das folgt direkt aus dem Bild der letzten Lektion. Der Callback liegt zu diesem Zeitpunkt frisch auf einem leeren Stapel, und unter ihm steht nichts mehr, was ihn auffangen könnte.

Mit einer Aufzeichnung im Reiter „Debug“ siehst du das. Die Reihenfolge lautet Zeile 7 (try {), Zeile 8 (der Aufruf), Zeile 2 (der setTimeout darin) und dann Zeile 12, die letzte Zeile im try-Block. Erst danach kommen Zeile 3, 9 und 10, also der Callback und sein throw. Der try-Block war schon durch, bevor der Callback überhaupt angefangen hat, und er kann nichts fangen, was es zu seiner Zeit noch gar nicht gab.

Die Fehlerbehandlung muss deshalb überall dort stehen, wo ein Ergebnis ankommt. An einer Stelle zusammenfassen lässt sie sich nicht. Bei drei verschachtelten Schritten stehen drei fast gleiche if (fehler) untereinander, und wenn du einen davon vergisst, merkst du es nie.

Was Promises daran ändern

Promises lösen diese beiden Probleme, deshalb kommen sie als Nächstes. Mit ihnen wird aus der Verschachtelung eine Kette, die untereinander steht, statt nach rechts zu wandern. Und ein Fehler wird die Kette entlang weitergegeben, bis ihn jemand abfängt, also reicht eine einzige Fehlerbehandlung für alle Schritte.

Callbacks verschwinden dabei nicht. Ein addEventListener bekommt weiterhin einen, setTimeout auch und map sowieso. Weg ist nur die Verschachtelung für Dinge, die nacheinander passieren müssen.

In der Aufgabe verkettest du drei Schritte im Callback-Stil, und einer davon kann scheitern.

Zum Mitnehmen

Ein Callback bekommt als erstes Argument den Fehler und danach das Ergebnis. Schritte, die aufeinander aufbauen, wandern dabei nach rechts, und ein try um den Aufruf fängt keinen Fehler, der erst im Callback entsteht.

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.