Abschnitt 18 · Lektion 6
Synthese: eine Komponente als Klasse
Zwei Zähler sollen auf derselben Seite stehen. Mit ein paar Variablen und Handlern nebeneinander klappt das nicht mehr. So war der Zähler aus Lektion 12.8 gebaut, und das ging nur, solange es einen gab. Jeder braucht seinen eigenen Stand, sein eigenes Element und seine eigenen Handler, und dafür bekommt das Muster eine Klasse.
Was eine Komponente ist
<div id="links"></div>
<div id="rechts"></div>
<p id="hinweis"></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;
}
.name {
font-weight: 600;
}
.stand {
min-width: 2rem;
color: #57534e;
}
.plus {
padding: 0.2rem 0.6rem;
border: 1px solid #d6d3d1;
border-radius: 6px;
background: #fafaf9;
cursor: pointer;
} class Zaehlwerk {
#stand = 0;
#wurzel;
#feld;
constructor(wurzel, name) {
this.#wurzel = wurzel;
this.#wurzel.innerHTML =
'<strong class="name"></strong> <span class="stand">0</span> <button class="plus" type="button">+1</button>';
this.#wurzel.querySelector(".name").textContent = name;
this.#feld = this.#wurzel.querySelector(".stand");
const plus = this.#wurzel.querySelector(".plus");
plus.setAttribute("aria-label", `${name} erhöhen`);
// Die Arrow Function behält this. Ohne sie zeigt es
// im Handler auf den Button (Lektion 7.3 und 12.2).
// Abgebaut wird hier noch nicht, das zeigt das dritte Beispiel.
plus.addEventListener("click", () => this.hoch());
}
hoch() {
this.#stand = this.#stand + 1;
this.#feld.textContent = String(this.#stand);
}
get stand() {
return this.#stand;
}
}
const links = new Zaehlwerk(document.getElementById("links"), "Links");
const rechts = new Zaehlwerk(document.getElementById("rechts"), "Rechts");
document.getElementById("hinweis").textContent =
"Die Stände der beiden Zähler sind unabhängig voneinander.";
console.log("Zwei Objekte, zwei Stände:", links.stand, rechts.stand); In reinem JavaScript ist eine Komponente eine Klasse, die vier Dinge kann.
- Sie bekommt ein Element, in dem sie leben darf.
- Sie zeichnet sich dort hinein.
- Sie verdrahtet ihre eigenen Ereignisse, und niemand von außen muss das für sie tun.
- Sie kann sich wieder abbauen.
Mehr braucht es nicht. React, Vue und Svelte tun darüber hinaus vor allem eins, sie automatisieren das Neuzeichnen. Das Grundmuster ist dieses hier.
Im echten Projekt stünde die Klasse in einer eigenen Datei mit export class Zaehlwerk, und die Seite holte sie mit import, aber hier steht sie in derselben app.js wie ihr Aufruf, weil sich in dieser Ansicht keine zweite Datei laden lässt.
Im ersten Beispiel hängt der Handler als Arrow Function am Button, () => this.hoch(). Stünde dort nur this.hoch, wäre this beim Klick der Button. Der Klick endete dann mit TypeError: Cannot read private member #stand from an object whose class did not declare it, denn ein Button hat kein #stand.
Das Element kommt als Argument
<div id="zaehler"></div>
<div id="zweiter"></div> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
.stand {
min-width: 2rem;
color: #57534e;
} // Das Gegenbeispiel: die Klasse sucht sich ihr Element
// selbst, über eine feste id.
class SchlechtesZaehlwerk {
#stand = 0;
constructor() {
this.wurzel = document.getElementById("zaehler");
this.wurzel.innerHTML = '<span class="stand">0</span>';
}
hoch() {
this.#stand = this.#stand + 1;
this.wurzel.querySelector(".stand").textContent = String(this.#stand);
}
}
const a = new SchlechtesZaehlwerk();
const b = new SchlechtesZaehlwerk();
a.hoch();
a.hoch();
b.hoch();
// Zwei Objekte, aber nur ein Element. Sie schreiben
// beide dorthin und überschreiben sich gegenseitig.
console.log("Im Element steht:", document.querySelector("#zaehler .stand").textContent);
console.log("Die zweite Anzeige ist leer:", document.getElementById("zweiter").innerHTML === "");
console.warn("Das zweite Objekt schreibt in die Anzeige des ersten."); Eine Komponente, die sich ihr Element mit document.getElementById("zaehler") selbst sucht, funktioniert genau einmal. Beim zweiten Einsatz greifen beide Objekte auf dasselbe Element zu und schreiben sich gegenseitig um.
Bekommt sie das Element übergeben, kannst du sie so oft einsetzen, wie du willst. Zum Ausprobieren reicht dann ein beliebiges Element, und es muss keine bestimmte id im Dokument stehen.
Im zweiten Beispiel steckt der Beweis in einer Zeile. Tippst du a.wurzel === b.wurzel in die Eingabezeile der Console, kommt true zurück. Zwei Objekte, ein Element. a allein zeigt dasselbe von der anderen Seite, SchlechtesZaehlwerk {wurzel: <div id="zaehler">}, und bei b steht dort dasselbe div.
Im ersten Beispiel lässt sich diese Frage nicht stellen, denn dort ist die Wurzel ein privates Feld. links.wurzel ergibt undefined, und ein Vergleich zweier undefined sagt gar nichts. Was die beiden trennt, siehst du dort an ihren Ständen.
Was eine Klasse braucht, bekommt sie übergeben, statt es sich selbst zu besorgen. Das gilt weit über Komponenten hinaus.
Der Zustand bleibt drin
Der Stand des Zählers ist ein privates Feld, und das hat hier einen Grund.
Könnte jeder von außen komponente.stand = 99 schreiben, stünde danach im Objekt eine Zahl und auf dem Bildschirm eine andere. Verhindern lässt sich das nur, wenn jede Änderung durch die Komponente selbst läuft, über eine Methode oder einen Setter, der gleich neu zeichnet. Ein offenes Feld kann das nicht.
Klickst du zweimal auf den linken Button und einmal auf den rechten, antwortet links.stand in der Eingabezeile der Console mit 2 und rechts.stand mit 1. Zwei Objekte, zwei Stände, und beide stimmen mit dem überein, was daneben steht.
Von außen klappt es nicht. links.stand = 99 antwortet mit 99, als wäre nichts gewesen, und links.stand ergibt danach weiter 2. Es gibt nur einen Getter und keinen Setter, also läuft die Zuweisung ins Leere. In der Eingabezeile passiert das ohne jede Meldung, in einem Modul gibt es einen TypeError, weil Module streng sind. So oder so bleibt der Stand bei 2.
links allein ergibt Zaehlwerk {}, ein Objekt, das von außen leer aussieht, obwohl es drei Felder hat. Daneben steht das Kurs {titel: "JavaScript", stunden: 50} vom Anfang des Abschnitts. Das eine sind Daten, die herumliegen, das andere ist ein Zustand, der jemandem gehört.
Nach außen gibt die Komponente deshalb nur zwei Dinge her, Methoden, die etwas tun, und Getter, die etwas verraten. Geändert wird der Zustand nur von innen, und wer ihn ändert, zeichnet auch neu.
Aufräumen beim Entfernen
<div id="platz"></div>
<p>
<button id="anlegen" type="button">Anlegen</button>
<button id="abbauen" type="button">Abbauen</button>
</p>
<p id="zaehlung"></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;
}
.zeit {
color: #78716c;
}
.plus {
padding: 0.2rem 0.6rem;
border: 1px solid #d6d3d1;
border-radius: 6px;
background: #fafaf9;
cursor: pointer;
} const zaehlung = document.getElementById("zaehlung");
let offeneListener = 0;
class Uhr {
#wurzel;
#kennung;
#beiKlick;
constructor(wurzel) {
this.#wurzel = wurzel;
this.#wurzel.innerHTML = '<span class="zeit">0</span> <button class="plus" type="button">+1</button>';
this.#beiKlick = () => console.log("Klick");
this.#wurzel.querySelector(".plus").addEventListener("click", this.#beiKlick);
offeneListener = offeneListener + 1;
// Auch ein laufender Timer gehört aufgeräumt.
let sekunden = 0;
this.#kennung = setInterval(() => {
sekunden = sekunden + 1;
const feld = this.#wurzel.querySelector(".zeit");
if (feld) {
feld.textContent = String(sekunden);
}
}, 1000);
melden();
}
zerstoeren() {
this.#wurzel.querySelector(".plus").removeEventListener("click", this.#beiKlick);
clearInterval(this.#kennung);
this.#wurzel.replaceChildren();
offeneListener = offeneListener - 1;
melden();
}
}
function melden() {
zaehlung.textContent = `Offene Listener: ${offeneListener}`;
}
let uhr = null;
const platz = document.getElementById("platz");
document.getElementById("anlegen").addEventListener("click", () => {
if (!uhr) {
uhr = new Uhr(platz);
}
});
document.getElementById("abbauen").addEventListener("click", () => {
if (uhr) {
uhr.zerstoeren();
uhr = null;
}
});
melden(); Diesen Teil vergisst man am leichtesten. Warum das teuer wird, steht in Lektion 12.7.
Wird eine Komponente entfernt, ohne aufzuräumen, bleibt einiges zurück. Ein setInterval läuft weiter und schreibt in ein Feld, das niemand mehr sieht. Listener an window oder document arbeiten bei jedem Ereignis für eine Ansicht, die es nicht mehr gibt. Nichts davon fällt sofort auf, sondern erst später, wenn die Seite träge wird und niemand weiß, warum.
Jede Komponente, die etwas anmeldet, hat deshalb eine Methode zum Abmelden. Hier heißt sie zerstoeren, anderswo destroy, dispose oder unmount. Der Name ist egal, Hauptsache, es gibt sie. Im ersten Beispiel fehlt sie noch, im dritten ist sie da.
Ich halte mich an eine einfache Regel. Für jedes addEventListener im constructor steht ein removeEventListener in der Abbaumethode, für jedes setInterval ein clearInterval. Der Handler muss dafür in einem Feld liegen, sonst findet removeEventListener nichts. Eine Arrow Function, die direkt in addEventListener steht, kennt danach niemand mehr. Ohne Feld geht es mit einem AbortController wie beim Abschalten der Buttons in Abschnitt 12. addEventListener bekommt sein signal mit, und abort() meldet alles auf einmal ab.
In der Aufgabe entsteht ein Zähler als Komponente, zweimal eingesetzt und mit einer Abbaumethode.
Zum Mitnehmen
Eine Komponente bekommt ihr Element, zeichnet sich hinein, verdrahtet ihre Ereignisse selbst und hält ihren Zustand privat. Sie kann sich wieder abbauen, und dafür steht zu jedem Anmelden ein Abmelden bereit.
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.