mitmario.dev

Abschluss: eine ganze Anwendung

JavaScript Im Browser 5 Min Lesezeit 3 BeispieleLektion 6 von 8

Vier Stücke aus diesem Kurs landen in der letzten Aufgabe in einer einzigen Anwendung, nämlich die Kartenliste, das geprüfte Formular, die Liste aus dem Netz und die gemerkten Einstellungen. Dort kommen sie sich zum ersten Mal gegenseitig in die Quere. Die Aufgabe ist die längste des Kurses und bringt nichts Neues mit. Sie braucht vor allem eine Ordnung, in der alle vier nebeneinander Platz haben.

Die Reihenfolge, in der man baut

Es gibt eine, und sie ist fast immer dieselbe.

  • Erst die Daten, also woher sie kommen und wie sie aussehen. Ein Beispielobjekt steht da, bevor irgendetwas anderes entsteht, denn alles Weitere hängt daran.
  • Dann die Logik, also filtern, sortieren, rechnen, prüfen. Das sind reine Funktionen, die Werte hinein und Werte heraus reichen. Sie lassen sich mit ein paar Beispielen abklopfen, ohne dass es eine Seite gibt.
  • Dann die Darstellung, eine Funktion, die aus dem aktuellen Stand die Ansicht baut.
  • Zuletzt die Bedienung, also Klicks, Eingaben, Formulare. Sie ändern den Stand und stoßen das Neuzeichnen an, mehr tun sie nicht.

Mit dem Aussehen anzufangen ist verlockend, weil man sofort etwas sieht. Es rächt sich trotzdem. Du baust Elemente für Daten, die es noch nicht gibt, und stellst beim Anschließen fest, dass die echten Daten anders aussehen. Dann siehst du zwar immer noch etwas, aber es stimmt nicht.

Ein Zustand in der Mitte

Ein Zustand, eine Zeichenfunktion
const AUFGABEN = [
  { titel: "Einkaufen", offen: true },
  { titel: "Steuer", offen: true },
  { titel: "Rasen mähen", offen: false },
  { titel: "Rechnung schreiben", offen: false },
];

// Der Zustand: alles, was die Ansicht bestimmt, an einer Stelle.
const zustand = { suche: "", nurOffen: false };

const liste = document.getElementById("liste");
const zaehler = document.getElementById("zaehler");

// Eine Funktion rechnet aus dem Zustand die sichtbare Liste.
function sichtbar() {
  return AUFGABEN.filter((aufgabe) => {
    const passtZurSuche = aufgabe.titel
      .toLowerCase()
      .includes(zustand.suche.toLowerCase());
    const passtZumFilter = !zustand.nurOffen || aufgabe.offen;
    return passtZurSuche && passtZumFilter;
  });
}

// Eine Funktion zeichnet alles neu. Immer alles.
function zeichnen() {
  const treffer = sichtbar();
  liste.replaceChildren();

  for (const aufgabe of treffer) {
    const eintrag = document.createElement("li");
    eintrag.classList.add("eintrag");
    eintrag.classList.toggle("erledigt", !aufgabe.offen);
    eintrag.textContent = aufgabe.titel;
    liste.append(eintrag);
  }

  zaehler.textContent = `${treffer.length} von ${AUFGABEN.length} sichtbar`;
}

// Die Ereignisse ändern nur den Zustand und zeichnen neu.
document.getElementById("suche").addEventListener("input", (ereignis) => {
  zustand.suche = ereignis.target.value;
  zeichnen();
});

document.getElementById("nur-offen").addEventListener("click", (ereignis) => {
  zustand.nurOffen = !zustand.nurOffen;
  // aria-pressed sagt einem Screenreader, ob der Filter an ist.
  ereignis.currentTarget.setAttribute("aria-pressed", String(zustand.nurOffen));
  zeichnen();
});

zeichnen();

Das ist das Muster, um das es geht. Es besteht aus drei Teilen.

  • Ein Objekt hält alles, was die Ansicht bestimmt. Hier sind es zwei Werte, ein Suchtext und ein Schalter. In größeren Anwendungen sind es zwanzig, und das Prinzip bleibt.
  • Eine Funktion zeichnet die Ansicht aus diesem Objekt, immer die ganze Ansicht und nicht nur den geänderten Teil. Das klingt verschwenderisch, ist bei dieser Größenordnung aber völlig unproblematisch.
  • Die Ereignisse ändern nur den Zustand und rufen dann zeichnen(). Kein Handler fasst ein Element direkt an.

Der Gewinn ist, dass es keine zweite Wahrheit gibt. Was auf dem Bildschirm steht, ist immer das Ergebnis des Zustands. Die Liste kann also nie gefiltert sein, während der Zähler etwas anderes behauptet.

Warum nicht ohne

Dieselbe Anwendung ohne Zustand
// Kein Zustand. Jeder Handler fasst direkt die Elemente an.
const eintraege = document.querySelectorAll(".eintrag");
const zaehler = document.getElementById("zaehler");

document.getElementById("suche").addEventListener("input", (ereignis) => {
  const suche = ereignis.target.value.toLowerCase();
  let sichtbare = 0;

  for (const eintrag of eintraege) {
    const passt = eintrag.textContent.toLowerCase().includes(suche);
    eintrag.hidden = !passt;
    if (passt) {
      sichtbare = sichtbare + 1;
    }
  }

  zaehler.textContent = `${sichtbare} von 4 sichtbar`;
});

document.getElementById("nur-offen").addEventListener("click", (ereignis) => {
  // Und hier fängt es an: dieser Handler weiß nichts von der
  // Suche. Erst etwas eintippen, dann den Button drücken.
  ereignis.currentTarget.setAttribute("aria-pressed", "true");
  for (const eintrag of eintraege) {
    eintrag.hidden = eintrag.dataset.offen === "false";
  }
});

Das zweite Beispiel ist kaputt, und man sieht es ihm nicht an. Nach „re“ in der Suche steht eine Zeile da, „Rechnung schreiben“, und der Zähler sagt „1 von 4 sichtbar“. So weit ist alles in Ordnung.

Ein Klick auf „Nur offene“ bringt drei Sachen auseinander. Im Suchfeld steht weiterhin „re“. Auf dem Bildschirm stehen „Einkaufen“ und „Steuer“, in keinem von beiden kommt „re“ vor, und die einzige Zeile, die zur Suche passte, ist verschwunden. Und der Zähler sagt immer noch „1 von 4 sichtbar“, obwohl zwei dastehen.

Keines davon ist ein Rechenfehler, jede der beiden Funktionen rechnet für sich richtig. Der zweite Handler weiß nur nichts vom ersten. Beide fassen dieselben Elemente an und überschreiben sich gegenseitig.

Reparieren ließe sich das, indem der zweite Handler die Suche mitliest und der erste den Filter. Bei zwei Bedienelementen sind das zwei Stellen, bei fünf sind es zwanzig. Spätestens dort ist ein zentraler Zustand keine Theorie mehr.

Die vier Ladezustände

Die vier Ladezustände einer Liste
const liste = document.getElementById("liste");
const status = document.getElementById("status");

async function laden(adresse, suche) {
  // Ladezustand: es läuft gerade.
  status.textContent = "Lade ...";
  liste.replaceChildren();

  try {
    const antwort = await fetch(adresse);
    if (!antwort.ok) {
      throw new Error(`Status ${antwort.status}`);
    }

    const kurse = await antwort.json();
    const treffer = kurse.filter((kurs) =>
      kurs.titel.toLowerCase().includes(suche)
    );

    if (treffer.length === 0) {
      // Ladezustand: geladen, aber nichts dabei.
      status.textContent = "Keine Kurse gefunden.";
      return;
    }

    // Ladezustand: Daten da.
    status.textContent = "";
    for (const kurs of treffer) {
      const eintrag = document.createElement("li");
      eintrag.textContent = `${kurs.titel} (${kurs.stunden} h)`;
      liste.append(eintrag);
    }
  } catch (fehler) {
    // Ladezustand: schiefgegangen.
    status.textContent = "Konnte nicht geladen werden.";
    console.error(fehler);
  }
}

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

document.getElementById("kaputt").addEventListener("click", () => {
  laden("/lernen/api/gibtesnicht.json", "");
});

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

Sie stammen aus Lektion 16.4 und sind für die Aufgabe der wichtigste Teil. Jede Liste, die aus dem Netz kommt, hat vier mögliche Ausgänge. Drei davon werden gern vergessen.

  • Es lädt gerade, und auf der Seite ist zu sehen, dass etwas passiert.
  • Es ist etwas da. Das ist der Normalfall, den alle bauen.
  • Es ist nichts da, also geladen, aber ohne Treffer. Eine leere Liste ohne Erklärung sieht aus wie ein Fehler.
  • Es ist schiefgegangen. Dann steht eine Meldung da, die sagt, was los ist, und nach Möglichkeit ein Button zum Wiederholen.

Die Abnahmeliste

Am Ende hilft eine Liste mit sechs Punkten. Fünf davon kannst du hier abhaken, ohne die Lektionsansicht zu verlassen.

  • Steht die Console leer? Am Reiter Console steht eine Zahl, und bei einem Fehler ist sie rot. Eine rote Zeile, die niemanden stört, stört später jemanden.
  • Gibt es alle vier Ladezustände? Die Aufgabe hat zwei Buttons dafür, einen fürs Laden und einen für eine Adresse, die es nicht gibt. Den Leerzustand bringt eine Suche ohne Treffer. Im Reiter Netzwerk steht dazu jede Anfrage mit ihrem Status, auch die mit 404.
  • Geht es ohne Maus? Nach einem Klick in die Seite führt Tab durch alles, und der Fokusring zeigt die Stelle. Die Titel der Karten haben dafür im Stylesheet einen eigenen.
  • Übersteht die Einstellung einen Neustart, sofern sie das soll? Ein Klick auf Seite neu laden zeigt es. Was im Browserspeicher liegt, überlebt das, das Zustandsobjekt nicht. In der Aufgabe ist das nicht zu sehen, weil die Prüfliste bei jedem Neuladen mitläuft und am Ende die Auswahl vergisst. Ohne Prüfliste siehst du es im ersten Beispiel von Lektion 17.1.
  • Was passiert bei leerer Eingabe, bei einem Leerzeichen, bei zweihundert Zeichen?
  • Was passiert bei kaputten Daten, einer fehlenden Eigenschaft, einem null, einem leeren Array? Das ist der eine Punkt, bei dem du selbst Hand anlegen musst. Du änderst dafür die Daten im Code, statt auf den Fall zu warten.

Was als Nächstes kommt

Was Frameworks einem abnehmen, hast du in diesem Kurs von Hand gebaut. Einen Zustand, eine Funktion, die daraus die Ansicht erzeugt, und Ereignisse, die den Zustand ändern. Das ist der Kern von React, Vue und Svelte. Sie nehmen dir das zeichnen() ab und rechnen selbst aus, welche Elemente sich geändert haben. Der Rest ist ihre Schreibweise.

Der Weg dorthin ist deshalb kürzer, als er aussieht. Wer das Muster verstanden hat, lernt ein Framework deutlich schneller, und wer es nicht verstanden hat, lernt Zauberformeln auswendig und steht beim ersten ungewöhnlichen Fall im Dunkeln.

Ich würde vorher zwei oder drei kleine Sachen ohne Framework bauen. Dabei kommen die Fragen, auf die ein Framework die Antwort ist.

In der Aufgabe entsteht ein Kurskatalog, der alle vier Stücke zusammenbringt, mit einem Zustand in der Mitte.

Zum Mitnehmen

Alles, was die Ansicht bestimmt, steht in einem Objekt, und eine einzige Funktion zeichnet daraus die ganze Seite. Handler ändern nur dieses Objekt. Dazu kommen die vier Ladezustände einer Liste aus dem Netz und eine Abnahmeliste für den Schluss.

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.