Abschnitt 12 · Lektion 7
Listener wieder entfernen
Ein Hinweis soll nur beim ersten Klick erscheinen. Und ein Bereich, der geschlossen wird, soll aufhören, auf Klicks zu reagieren. Ein Listener bleibt aber, bis ihn jemand löst, und das Lösen hat einen Haken.
Der Haken an removeEventListener
<p><button id="benannt" type="button">Benannte Funktion</button> <span id="a">0</span></p>
<p><button id="direkt" type="button">Arrow direkt hingeschrieben</button> <span id="b">0</span></p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
}
button,
input,
select,
textarea {
font: inherit;
}
button {
padding: 0.4rem 0.8rem;
border: 1px solid #d6d3d1;
border-radius: 6px;
background: #fafaf9;
cursor: pointer;
} let a = 0;
let b = 0;
// Eine benannte Funktion: es gibt sie genau einmal.
function zaehleA() {
a = a + 1;
document.getElementById("a").textContent = String(a);
}
const benannt = document.getElementById("benannt");
benannt.addEventListener("click", zaehleA);
benannt.removeEventListener("click", zaehleA);
console.log("Der erste Button reagiert jetzt nicht mehr.");
// Und hier zweimal dieselbe Schreibweise, aber zwei Funktionen.
const direkt = document.getElementById("direkt");
direkt.addEventListener("click", () => {
b = b + 1;
document.getElementById("b").textContent = String(b);
});
direkt.removeEventListener("click", () => {
b = b + 1;
document.getElementById("b").textContent = String(b);
});
console.log("Der zweite Button zählt weiter.");
// Gleicher Text, aber zwei verschiedene Werte.
console.log("gleich?", (() => 1).toString() === (() => 1).toString());
console.log("und als Wert?", (() => 1) === (() => 1)); removeEventListener("click", zaehleA) löst den Listener wieder. Damit das klappt, müssen das Element, der Name des Ereignisses, die Phase und die Funktion selbst übereinstimmen. Hast du mit true für die Capturing-Phase angemeldet, meldest du auch mit true ab.
An der Funktion hängt alles. Gemeint ist nicht eine Funktion, die genauso aussieht, sondern dieselbe. Zwei Arrow Functions mit identischem Inhalt sind zwei verschiedene Werte, wie zwei Objekte mit denselben Eigenschaften. Das ist derselbe Vergleich wie in Lektion 6.4.
Eine direkt hingeschriebene Arrow Function lässt sich deshalb mit removeEventListener nie entfernen. Beim addEventListener entsteht eine, beim removeEventListener eine zweite, und die kennt der Browser nicht. Einen Fehler gibt es dabei nicht. Der Browser sucht, findet nichts und tut nichts.
In der Eingabezeile der Console antwortet (() => 1) === (() => 1) mit false. Zwei Funktionen, so gleich sie auch aussehen. zaehleA === zaehleA antwortet mit true, denn die benannte gibt es genau einmal, und deshalb findet removeEventListener sie wieder.
Ich benenne die Funktion deshalb vorher. Dann gibt es sie genau einmal, und beide Aufrufe meinen dieselbe.
once für den Einmal-Fall
<p><button id="einmal" type="button">Nur einmal</button> <span id="a">0</span></p>
<p><button id="immer" type="button">Immer</button> <span id="b">0</span></p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
}
button,
input,
select,
textarea {
font: inherit;
}
button {
padding: 0.4rem 0.8rem;
border: 1px solid #d6d3d1;
border-radius: 6px;
background: #fafaf9;
cursor: pointer;
} let a = 0;
let b = 0;
// once: true entfernt den Listener nach dem ersten Feuern
// von selbst. Man muss ihn nicht mehr aufheben.
document.getElementById("einmal").addEventListener(
"click",
() => {
a = a + 1;
document.getElementById("a").textContent = String(a);
console.log("einmal gelaufen, jetzt bin ich weg");
},
{ once: true }
);
document.getElementById("immer").addEventListener("click", () => {
b = b + 1;
document.getElementById("b").textContent = String(b);
});
console.log("Bei mehreren Klicks zählt nur der zweite Button weiter."); Soll ein Listener nur beim ersten Mal reagieren, brauchst du weder removeEventListener noch einen eigenen Zähler, denn dafür gibt es eine Option.
{ once: true } als drittes Argument sagt dem Browser, er soll den Handler einmal aufrufen und danach wegwerfen. Aufgeräumt wird also von selbst.
Das ist kürzer als die Alternative und kann nicht auseinanderlaufen. Ein selbst geführter Merker mit if (schonGelaufen) return; funktioniert auch, hält den Listener aber am Leben und verteilt die Bedingung im Code.
AbortController für mehrere auf einmal
<p><button id="eins" type="button">Eins</button> <button id="zwei" type="button">Zwei</button></p>
<p><button id="aus" type="button">Alles abschalten</button></p>
<p id="ausgabe">bereit</p> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
p {
margin: 0 0 0.75rem;
}
button,
input,
select,
textarea {
font: inherit;
}
button {
padding: 0.4rem 0.8rem;
border: 1px solid #d6d3d1;
border-radius: 6px;
background: #fafaf9;
cursor: pointer;
} const ausgabe = document.getElementById("ausgabe");
// Ein Controller, ein Signal, beliebig viele Listener.
const steuerung = new AbortController();
const optionen = { signal: steuerung.signal };
document.getElementById("eins").addEventListener(
"click",
() => { ausgabe.textContent = "Eins geklickt"; },
optionen
);
document.getElementById("zwei").addEventListener(
"click",
() => { ausgabe.textContent = "Zwei geklickt"; },
optionen
);
// Ein Aufruf löst alle auf einmal.
document.getElementById("aus").addEventListener("click", () => {
steuerung.abort();
ausgabe.textContent = "abgeschaltet";
console.log("beide Listener sind weg");
});
console.log("Nach Alles abschalten reagieren Eins und Zwei nicht mehr."); Soll ein ganzer Bereich aufhören zuzuhören, wird das einzelne Entfernen mühsam. Jede Funktion braucht einen Namen, und bei jedem Aufruf musst du dir das Element merken.
Einfacher geht es mit einem AbortController. Du legst einen an und gibst sein signal als Option an alle Listener, und dann löst ein einziges steuerung.abort() sie alle auf einmal.
Denselben Controller gibt es in Abschnitt 16 wieder. Dort bricht er eine laufende Anfrage ab, derselbe Mechanismus für zwei ganz verschiedene Dinge.
Ein Controller ist verbraucht, sobald er ausgelöst hat. Soll wieder zugehört werden, brauchst du einen neuen, und die Listener müssen neu gesetzt werden.
Warum das überhaupt zählt
Ein Listener hängt an seinem Element und verschwindet mit ihm. Wird ein Eintrag entfernt und zeigt sonst nichts mehr auf ihn, räumt der Browser beides zusammen weg.
Teuer wird ein Listener an etwas, das bleibt, also an window, an document oder an einem Container. Alles, was sein Handler von außen kennt, hält er nämlich fest, auch Elemente, die längst nicht mehr auf der Seite stehen. Und er läuft bei jedem Ereignis weiter, für eine Ansicht, die es nicht mehr gibt.
Bei einer Seite, die nach einem Klick sowieso neu lädt, spielt das keine Rolle. Bei einer Anwendung, die stundenlang offen bleibt und dabei laufend Bereiche auf- und abbaut, summiert es sich aber, und das nennt man dann ein Speicherleck.
Mit Delegation wie in der vorigen Lektion hast du dieses Problem kaum. Am Container hängt ein einziger Listener, der so lange bleiben soll wie die Liste, und die Einträge darunter kommen und gehen ohne eigene Listener.
In der Aufgabe reagiert ein Button nur einmal und ein zweiter so lange, bis ein dritter ihn abschaltet.
Zum Mitnehmen
removeEventListener braucht genau dieselbe Funktion, eine direkt hingeschriebene Arrow Function trifft es deshalb nie. once löst einen Listener nach dem ersten Mal von selbst, ein AbortController mehrere auf einmal.
Jetzt du
Basis Konto, kostenlosZu 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.