mitmario.dev

Ladezustände anzeigen

JavaScript Im Browser 3 Min Lesezeit 3 BeispieleLektion 4 von 7

Nach dem Klick dauert es eine Weile, bis die Daten da sind. Was in dieser Zeit auf dem Bildschirm steht, entscheidet darüber, ob jemand die Seite für kaputt hält.

Vier Zustände, nicht zwei

Die vier Zustände nacheinander
const statusFeld = document.getElementById("status");
const liste = document.getElementById("liste");

function verzoegern(ms) {
  return new Promise((fertig) => setTimeout(fertig, ms));
}

function zeichnen(titel) {
  liste.replaceChildren();
  for (const eintrag of titel) {
    const li = document.createElement("li");
    li.textContent = eintrag;
    liste.append(li);
  }
}

async function vorfuehren() {
  statusFeld.textContent = "Lädt ...";
  await verzoegern(700);

  zeichnen(["HTML", "CSS", "JavaScript"]);
  statusFeld.textContent = "";
  await verzoegern(900);

  zeichnen([]);
  statusFeld.textContent = "Keine Einträge";
  await verzoegern(900);

  zeichnen([]);
  statusFeld.textContent = "Die Liste konnte nicht geladen werden.";
}

document.getElementById("los").addEventListener("click", vorfuehren);

Gebaut werden oft nur zwei, es lädt und es ist da. Tatsächlich sind es vier.

  1. Es lädt. Etwas ist unterwegs, und auf der Seite ist zu sehen, dass gearbeitet wird.
  2. Es ist da. Die Daten stehen auf der Seite.
  3. Es ist da und leer. Der Server hat geantwortet, alles hat funktioniert, es gibt nur nichts anzuzeigen, etwa nach einem Filter, der nichts übriglässt, oder einer Suche ohne Treffer.
  4. Es ist schiefgegangen. Die Verbindung ist weg, der Server kaputt oder die Adresse falsch.

Der dritte wird gern vergessen, und er ist der ärgerlichste. Wenn die leere Liste aussieht wie ein Ladezustand, der nie endet, kann niemand erkennen, was los ist.

Im ersten Beispiel stehen alle vier hintereinander, und „leer“ und „fehlgeschlagen“ wirken ganz unterschiedlich, obwohl in beiden Fällen nichts in der Liste steht.

Die Wartezeiten darin sind eingebaut, ein fetch steht dort gar nicht. Das ging nicht anders, weil die Übungsdaten gleich nebenan liegen. In Lektion 16.2 stand im Reiter „Netzwerk“ die Dauer der echten Anfrage, ein paar Millisekunden, und in dieser Zeit wäre ein Ladehinweis schon wieder weg, bevor du ihn überhaupt bemerkst. Auf einem Handy in einem vollen Zug sind es zwei Sekunden. Dafür wird er gebaut.

Ich baue alle vier von Anfang an. Einen Zustand nachträglich einzuziehen heißt, jede Stelle wiederzufinden, an der die Ansicht etwas schreibt.

finally ist hier zu Hause

finally räumt in jedem Fall auf
const statusFeld = document.getElementById("status");

async function laden(button, adresse) {
  statusFeld.textContent = "Lädt ...";
  button.disabled = true;
  console.log("Button gesperrt:", button.id);

  try {
    const antwort = await fetch(adresse);
    if (!antwort.ok) {
      throw new Error(`Server meldet ${antwort.status}`);
    }
    const daten = await antwort.json();
    statusFeld.textContent = `${daten.length} Einträge geladen.`;
  } catch (fehler) {
    statusFeld.textContent = "Konnte nicht geladen werden.";
    console.warn("Fehlgeschlagen:", fehler.message);
  } finally {
    // Läuft in beiden Fällen. Ohne das bliebe der Button nach
    // einem Fehler für immer gesperrt.
    button.disabled = false;
    console.log("Button wieder frei:", button.id);
  }
}

const gut = document.getElementById("gut");
const kaputt = document.getElementById("kaputt");

gut.addEventListener("click", () => laden(gut, "/lernen/api/kurse.json"));
kaputt.addEventListener("click", () => laden(kaputt, "/lernen/api/gibtesnicht.json"));

In Lektion 14.2 hat finally einen Button wieder freigegeben. Hier räumt es nach einer Anfrage auf, und dafür ist es eigentlich gebaut.

Was beim Laden angeschaltet wird, muss danach wieder aus, und zwar unabhängig davon, wie es ausgegangen ist. Der Ladehinweis, der gesperrte Button, ein Drehsymbol, alles davon gehört ins finally.

Ohne finally steht dieselbe Zeile zweimal da, einmal am Ende des try und einmal im catch. Beim dritten Mal wird eine davon vergessen. Dann bleibt der Button nach einem Fehler für immer gesperrt.

Warum der Button gesperrt wird

Die langsamere Antwort gewinnt
const ergebnis = document.getElementById("ergebnis");

function verzoegern(ms) {
  return new Promise((fertig) => setTimeout(fertig, ms));
}

async function laden(adresse, dauer, name) {
  console.log("Start:", name);
  await verzoegern(dauer);

  const antwort = await fetch(adresse);
  const daten = await antwort.json();

  console.log("Fertig:", name);
  // Wer zuletzt schreibt, gewinnt. Und das ist nicht der,
  // der zuletzt geklickt hat.
  ergebnis.textContent = `${name}: ${daten.length} Einträge`;
}

document.getElementById("langsam").addEventListener("click", () => {
  laden("/lernen/api/katalog.json", 1200, "langsam");
});

document.getElementById("schnell").addEventListener("click", () => {
  laden("/lernen/api/kurse.json", 100, "schnell");
});

Ein Button, der während des Ladens klickbar bleibt, wird auch geklickt. Dann sind zwei Anfragen unterwegs, und beide schreiben am Ende in dasselbe Element.

Das Problem ist die Reihenfolge. Wer zuletzt antwortet, gewinnt, und das muss nicht der sein, der zuletzt gestartet ist. Im dritten Beispiel geht der erste Klick auf „Langsam“ und der zweite auf „Schnell“, und angezeigt wird trotzdem das Ergebnis von „Langsam“, weil es später eintrifft. Auf der Seite steht dann ein Ergebnis, das niemand zuletzt angefordert hat.

Der einfachste Ausweg ist, den Button zu sperren. Zwei weitere gibt es noch. Mit einer laufenden Nummer, die sich der Code merkt, wird jede Antwort verworfen, deren Nummer nicht die aktuelle ist. Oder die alte Anfrage wird wirklich abgebrochen, mit einem AbortController. Sein signal geht an fetch mit, beim nächsten Start ruft der Code controller.abort() auf, und die alte Anfrage wird mit einem AbortError abgelehnt. Den behandelt das catch gesondert, damit bei einem absichtlichen Abbruch keine Fehlermeldung auf der Seite landet.

Der Ladehinweis, der zu früh kommt

Wenn die Antwort in 40 Millisekunden da ist, blitzt ein sofort eingeblendeter Ladehinweis kurz auf und verschwindet wieder, und das wirkt hektischer als gar kein Hinweis.

Deshalb wartet man mit dem Einblenden ungefähr 200 Millisekunden, mit setTimeout beim Start und clearTimeout, sobald die Antwort eintrifft. Ist sie schnell da, war der Hinweis nie zu sehen. Dauert es länger, erscheint er.

In der Aufgabe fehlt diese Verzögerung, damit der Hinweis beim Prüfen zu sehen ist. Dort baust du alle vier Zustände an einer ladenden Liste.

Zum Mitnehmen

Jede ladende Ansicht kennt vier Zustände, lädt, da, da und leer, fehlgeschlagen. Was beim Laden angeht, schaltet finally wieder aus, und ein gesperrter Button verhindert, dass eine langsamere Antwort eine neuere überholt.

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.