mitmario.dev

Event-Delegation

JavaScript Im Browser 3 Min Lesezeit 3 BeispieleLektion 6 von 9

Listen entstehen in diesem Kurs aus Daten. Jeder Eintrag hat einen Button, und jeder Button soll etwas tun. Naheliegend wäre, nach dem Zeichnen über alle Buttons zu laufen und jedem einen Listener zu geben. Das funktioniert genau einmal. Sobald die Liste neu gezeichnet wird, und das passiert nach jedem Filtern, Sortieren und Hinzufügen, sind die alten Elemente weg, und die neuen haben keine Listener. Also musst du sie neu setzen, jedes Mal. Schwer ist das nicht, aber es ist eine Buchführung, die nie fertig wird.

Ein Listener am Elternteil

Ein Listener statt vieler
const liste = document.getElementById("liste");
const ausgabe = document.getElementById("ausgabe");

// EIN Listener, am gemeinsamen Elternteil.
liste.addEventListener("click", (event) => {
  // Wo genau war der Klick? Vielleicht daneben.
  const button = event.target.closest(".abhaken");
  if (!button) return;

  const eintrag = button.closest("li");
  eintrag.classList.add("erledigt");
  ausgabe.textContent = `zuletzt erledigt: ${eintrag.dataset.id}`;
  console.log("Klick auf", eintrag.dataset.id);
});

// Die Alternative wären drei Listener gewesen, und bei
// dreihundert Einträgen dreihundert.
console.log("Ein Klick auf einen Button hakt ab, ein Klick daneben tut nichts.");

Der Listener hängt am gemeinsamen Elternteil. Der Container selbst wird nicht neu gezeichnet, nur sein Inhalt, also überlebt der Listener alles.

Das geht, weil Ereignisse aufsteigen. Ein Klick auf einen Button tief in der Liste kommt am Container an, und an event.target siehst du, wo er herkam.

Im Handler steht dann immer dasselbe Muster.

  1. Herausfinden, was gemeint war. event.target.closest(".abhaken") sucht von der Klickstelle aus nach oben den nächsten passenden Vorfahren, und das Element selbst zählt mit.
  2. Früh aussteigen. Passt nichts, ging der Klick daneben, und der Handler hört auf. Das ist die Zeile if (!button) return;, und ohne sie bricht der nächste Zugriff mit einem TypeError ab.
  3. Die Arbeit tun. Über closest geht es noch einmal nach oben zum Eintrag, und an dessen data-id siehst du, welcher Datensatz gemeint war. Deshalb bekommt in Lektion 11.7 jedes erzeugte Element seine Kennung mit.

Warum closest und nicht target

Warum closest und nicht target
const liste = document.getElementById("liste");

liste.addEventListener("click", (event) => {
  // target ist das, was genau unter dem Zeiger lag. Beim
  // Wort Stern ist das der span und nicht der Button.
  const naiv = event.target.classList.contains("button");
  document.getElementById("naiv").textContent = `naiv: Button getroffen? ${naiv}`;

  // Von target aus nach oben suchen, das Element selbst
  // zählt dabei mit.
  const button = event.target.closest(".button");
  document.getElementById("richtig").textContent =
    `mit closest: Button getroffen? ${Boolean(button)}`;

  console.log("target war:", event.target.tagName, event.target.className);
});

console.log("Ein Klick auf das Wort Stern und einer auf JavaScript zeigen den Unterschied.");

event.target ist das Element, das genau unter dem Zeiger lag. Bei einem Button mit einem Symbol darin ist das oft das Symbol und nicht der Button.

Ein event.target.classList.contains("button") ist deshalb ein Fehler, der zufällig manchmal funktioniert. Er trifft, solange der Klick auf den Rand des Buttons geht. Trifft er das Symbol in der Mitte, geht er daneben. Wer zum Ausprobieren immer auf dieselbe Stelle klickt, merkt davon nichts.

Mit closest fragst du stattdessen das, was du wirklich wissen willst, nämlich ob die Klickstelle irgendwo innerhalb eines Buttons liegt.

Was ein Listener je Eintrag nicht kann

Was ein Listener je Eintrag nicht kann
const liste = document.getElementById("liste");
const einzeln = document.getElementById("einzeln");
const delegiert = document.getElementById("delegiert");
const weitere = ["CSS", "JavaScript", "PHP", "Python", "SQL"];
let naechster = 0;

// Zwei getrennte Ausgaben, damit du beide nebeneinander siehst.
// In eine gemeinsame geschrieben würde der delegierte Listener
// den anderen jedes Mal überschreiben, denn er läuft später.

// Der einzelne Listener: wird jetzt gesetzt, für das eine
// Element, das es jetzt gibt.
document.querySelector(".button").addEventListener("click", (event) => {
  einzeln.textContent = event.currentTarget.textContent;
});

// Der delegierte Listener: kennt gar keine Buttons, nur die Liste.
liste.addEventListener("click", (event) => {
  const button = event.target.closest(".button");
  if (!button) return;
  delegiert.textContent = button.textContent;
});

document.getElementById("mehr").addEventListener("click", () => {
  const eintrag = document.createElement("li");
  const button = document.createElement("button");
  button.type = "button";
  button.classList.add("button");
  button.textContent = weitere[naechster % weitere.length];
  naechster = naechster + 1;
  eintrag.append(button);
  liste.append(eintrag);
});

console.log("Beim ersten Button ändern sich beide Zeilen, bei jedem neu hinzugefügten nur die untere.");

Im dritten Beispiel hängen beide Fassungen nebeneinander an derselben Liste.

Der einzelne Listener wurde beim Laden gesetzt, für den einen Button, den es damals gab. Einen später dazugekommenen Button kennt er nicht und wird ihn auch nie kennenlernen. Klickst du auf „HTML“ und legst einen neuen Eintrag an, bleibt die obere Zeile stehen, und die untere geht mit.

Der delegierte Listener kennt gar keine Buttons. Er kennt die Liste, und die ändert sich nicht. Ein Eintrag, der zehn Minuten später erzeugt wird, funktioniert deshalb genauso wie der erste. Damit gilt er für alles, was noch kommt, und nach dem Neuzeichnen musst du nichts neu verdrahten. Abmelden muss man auch nichts, denn ein Eintrag, der wegfällt, hat keinen eigenen Listener.

Wo die Grenze liegt

Delegation mit einem gewöhnlichen Listener klappt nur, wenn das Ereignis aufsteigt, und bei focus, blur, mouseenter und mouseleave tut es das nicht. Für die ersten beiden gibt es focusin und focusout, die aufsteigen. Für mouseenter und mouseleave gibt es mouseover und mouseout. Die feuern dafür bei jedem Wechsel zwischen Kindelementen, und das musst du dann selbst abfangen.

In der Aufgabe wird eine Liste, die wächst, mit einem einzigen Listener bedienbar.

Zum Mitnehmen

Ein Listener am Elternteil findet mit event.target.closest heraus, welcher Button gemeint war, und steigt aus, wenn der Klick daneben ging. Er gilt auch für Einträge, die es beim Setzen des Listeners noch gar nicht gab.

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.