Abschnitt 10 · Lektion 3
Durch den Baum laufen
Ein Klick auf einen Button soll die Karte finden, in der er steckt, und von dort ihre Überschrift. querySelector sucht von oben über die ganze Seite und weiß nicht, wo der Button steht. Das braucht es hier auch gar nicht, denn jedes Element kennt seine Nachbarschaft.
Drei Richtungen
<div class="liste">
<article id="karte-1"><h2>HTML</h2><button type="button">Mehr zu HTML</button></article>
<article id="karte-2"><h2>CSS</h2><button type="button">Mehr zu CSS</button></article>
<article id="karte-3"><h2>JavaScript</h2><button type="button">Mehr zu JavaScript</button></article>
</div> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
h2 {
font-size: 1.2rem;
margin: 1.25rem 0 0.5rem;
}
button,
input,
select,
textarea {
font: inherit;
}
button {
padding: 0.4rem 0.8rem;
border: 1px solid #d6d3d1;
border-radius: 6px;
background: #fafaf9;
cursor: pointer;
} const zweite = document.querySelector("#karte-2");
// Nach oben.
console.log("Eltern:", zweite.parentElement.className);
// Nach unten.
console.log("Kinder:", zweite.children.length);
console.log("erstes Kind:", zweite.firstElementChild.tagName);
console.log("letztes Kind:", zweite.lastElementChild.tagName);
// Zur Seite.
console.log("davor:", zweite.previousElementSibling.id);
console.log("danach:", zweite.nextElementSibling.id);
// Am Rand gibt es keinen Nachbarn. Dann kommt null.
const erste = document.querySelector("#karte-1");
console.log("vor der ersten:", erste.previousElementSibling); Nach oben geht es mit parentElement. Nach unten geht es mit children, firstElementChild und lastElementChild, zur Seite mit nextElementSibling und previousElementSibling.
Die Namen sind lang, dafür aber eindeutig. children ist eine HTMLCollection wie bei getElementsByTagName, firstElementChild ein einzelnes Element, und alle Geschwister-Eigenschaften liefern genau eines.
Am Rand gibt es keinen Nachbarn, und dann kommt null. Vor dem ersten Kind steht kein previousElementSibling, über <html> steht kein parentElement. Was du mit so einem null machst, kommt in der nächsten Lektion.
Warum immer die lange Variante
<div class="liste">
<article>HTML</article>
<article>CSS</article>
</div> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
} const liste = document.querySelector(".liste");
// Mit Element im Namen nur Elemente.
console.log("children:", liste.children.length);
console.log("firstElementChild:", liste.firstElementChild.tagName);
// Ohne Element im Namen auch Textknoten. Und zwischen
// den Tags im Markup steht ein Zeilenumbruch mit Einzug,
// also ein Textknoten.
console.log("childNodes:", liste.childNodes.length);
console.log("firstChild:", liste.firstChild.nodeName);
// Deshalb ist firstChild fast nie das, was man meint.
// JSON.stringify setzt den Text in Anführungszeichen und schreibt
// den Umbruch als \n, sonst sähe der Leerraum in der Console
// wie nichts aus. Was JSON sonst ist, kommt in Abschnitt 16.
console.log("firstChild Inhalt:", JSON.stringify(liste.firstChild.textContent));
// Und ohne Leerraum im Markup wäre es plötzlich richtig,
// was die Sache noch verwirrender macht.
const eng = document.createElement("div");
eng.innerHTML = "<b>a</b><i>b</i>";
console.log("ohne Leerraum:", eng.firstChild.nodeName); Zu fast jeder dieser Eigenschaften gibt es eine zweite ohne das Wort Element, nämlich childNodes, firstChild und nextSibling. Die sind älter, und sie zählen Knoten statt Elemente.
Ein Knoten ist auch ein Textstück. Zwischen zwei Tags im Markup steht fast immer ein Zeilenumbruch mit Einzug, also Text. Das ist ein Textknoten, auch wenn man nichts davon sieht.
Deshalb ist liste.childNodes.length bei zwei Artikeln nicht 2, sondern 5. Und liste.firstChild ist nicht der erste Artikel, sondern der Zeilenumbruch davor. In der Eingabezeile der Console antwortet document.querySelector(".liste").childNodes.length mit 5. Stünde das ganze Markup ohne Leerraum in einer Zeile, also <div class="liste"><article>HTML</article><article>CSS</article></div>, käme bei derselben Frage 2 heraus. Jedes Leerzeichen oder jeder Umbruch dazwischen wäre wieder ein Knoten mehr.
Unangenehm ist, dass es manchmal doch funktioniert. Ohne Leerraum ist firstChild das erwartete Element, und wer sich darauf verlässt, merkt den Fehler erst an dem Tag, an dem jemand das Markup ordentlich einrückt. Ich nehme deshalb immer die Variante mit Element im Namen. In diesem Kurs gibt es keinen Fall, in dem die andere richtig wäre.
Nach oben bis zur Karte
<div class="liste">
<article id="karte-2" class="karte">
<h2>CSS</h2>
<p>Gestaltung und Layout. <button type="button">Mehr zu CSS</button></p>
</article>
</div> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
h2 {
font-size: 1.2rem;
margin: 1.25rem 0 0.5rem;
}
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 button = document.querySelector("button");
// Von Hand hangeln, wenn man die Struktur genau kennt.
console.log("von Hand:", button.parentElement.parentElement.id);
// Mit closest, wenn man sie nicht genau kennt. Es sucht vom
// Element aus nach oben den nächsten passenden Vorfahren.
console.log("mit closest:", button.closest(".karte").id);
// Das Element selbst zählt mit. closest fängt bei ihm an.
console.log("bei sich selbst:", button.closest("button").tagName);
// Kein passender Vorfahre heißt null.
console.log("nichts gefunden:", button.closest(".gibtesnicht"));
// Und von der Karte aus wieder nach unten suchen.
const karte = button.closest(".karte");
console.log("Überschrift dazu:", karte.querySelector("h2").textContent); closest sucht vom Element aus nach oben den nächsten Vorfahren, der zu einem Selektor passt. Ein Vorfahre ist jedes Element weiter oben auf dem Weg zur Wurzel, also das Elternelement, dessen Elternelement und so weiter. Das Element selbst zählt mit.
Von Hand geht es auch, mit button.parentElement.parentElement. Nur steckt in dieser Kette die Struktur des Markups. Kommt später ein <div> dazwischen, stimmt sie nicht mehr, und zwar ohne dass es jemand merkt.
button.closest(".karte") sagt dagegen, was gemeint ist, nämlich die Karte, in der dieser Button steckt. Wie viele Ebenen dazwischenliegen, ist der Methode egal und dir beim Lesen auch.
Mit dem Inspector kannst du das am Beispiel nachstellen. Ist der Button festgeklickt, heißt er in der Eingabezeile der Console $0. $0.closest(".karte") antwortet dort mit <article id="karte-2" class="karte">, $0.parentElement dagegen nur mit <p>, dem Absatz dazwischen. $0.closest(".gibtesnicht") antwortet mit null. Ohne Fehler, denn dass es keinen passenden Vorfahren gibt, ist auch eine Antwort.
Der übliche Doppelschritt geht mit closest nach oben zum Container und von dort mit querySelector wieder nach unten. So findet in Abschnitt 12 ein Klick irgendwo in einer Liste den Eintrag, zu dem er gehört, und zwar in einer Zeile statt mit Kletterei von Hand.
Ob ein Element passt
<div class="karte hervor" data-kurs="javascript"><h2>JavaScript</h2></div>
<div class="karte"><h2>CSS</h2></div> body {
font-family: system-ui, sans-serif;
max-width: 40rem;
margin: 0;
padding: 1rem;
line-height: 1.6;
color: #1c1917;
}
h2 {
font-size: 1.2rem;
margin: 1.25rem 0 0.5rem;
} const erste = document.querySelector(".karte");
// matches prüft, ob ein Element zu einem Selektor passt.
console.log("hervor:", erste.matches(".hervor"));
console.log("mit Attribut:", erste.matches("[data-kurs]"));
console.log("nicht:", erste.matches(".gibtesnicht"));
// Damit lässt sich eine NodeList filtern, ohne den
// Selektor zweimal zu schreiben.
const alle = Array.from(document.querySelectorAll(".karte"));
const hervorgehoben = alle.filter((karte) => karte.matches(".hervor"));
console.log("gefiltert:", hervorgehoben.length);
// classList.contains kann fast dasselbe, aber nur für Klassen.
console.log("classList:", erste.classList.contains("hervor"));
// matches versteht dagegen jeden Selektor.
console.log("zusammengesetzt:", erste.matches(".karte[data-kurs='javascript']")); matches sagt, ob ein Element zu einem Selektor passt. Es liefert true oder false und ändert nichts. Damit kannst du eine Liste von Elementen filtern, ohne den Selektor doppelt zu schreiben.
classList.contains kann fast dasselbe, allerdings nur für Klassen. matches versteht jeden Selektor, also auch Kombinationen und Attribute in eckigen Klammern. [data-kurs] passt auf jedes Element mit diesem Attribut, [data-kurs='javascript'] nur auf eines mit dem Wert javascript. Bei einer reinen Klassenfrage liest sich contains etwas direkter.
In der Aufgabe fangen vier Funktionen bei einem Button an. Von dort finden sie die Karte, ihre Überschrift, die Karte danach und die Antwort auf einen Selektor.
Zum Mitnehmen
parentElement, children und die Geschwister führen durch den Baum, immer in der Variante mit Element im Namen, weil die andere Textknoten mitzählt. closest sucht nach oben den nächsten passenden Vorfahren und braucht die Struktur dazwischen nicht zu kennen.
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 4 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe im Editor, direkt im Browser geprüft
Öffnet sich mit dem Basis Konto.