WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / JavaScript

`contains()` und `parentElement`: DOM-Nachfahren und direkte Elternknoten

`contains()` prüft, ob ein Knoten derselbe Knoten oder ein Nachfahre ist. `parentElement` liefert den direkten Elternknoten nur dann, wenn er ein Element ist.

Version: ECMAScript 2024 and the current web platform; runtime support varies

Syntax

container.contains(otherNode) // boolean; pass a Node or null
node.parentElement            // Element or null; read-only

container.contains(otherNode) liefert true, wenn otherNode mit container identisch oder ein Nachfahre in beliebiger Tiefe ist, etwa ein Textknoten. Für null liefert die Methode false. Fehlt das erforderliche Argument oder wird eine Zeichenkette übergeben, löst sie einen TypeError aus. Mit otherNode !== container && container.contains(otherNode) schließt du container selbst aus.

node.parentElement ist eine schreibgeschützte Eigenschaft, keine Methode. Sie liefert den direkten Elternknoten, wenn er ein Element ist. Fehlt ein Elternknoten oder hat er einen anderen Typ, etwa Document oder DocumentFragment, ist das Ergebnis null. Die Eigenschaft sucht nicht weiter oben im Baum. Mit node.parentNode erhältst du den direkten Elternknoten unabhängig von seinem Typ.

Beide Abfragen spiegeln die aktuelle Baumstruktur wider, auch wenn der Baum nicht mit dem Dokument verbunden ist. Das Verschieben eines Knotens kann das Ergebnis ändern. Keine der Abfragen überquert die Grenze vom Shadow-Baum zum Host: Aus Sicht von contains() enthält der Host seine Shadow-Knoten nicht, und bei einem direkten Kind eines ShadowRoot ist parentElement gleich null.

Beides gehört zur DOM-Schnittstelle Node und nicht zum Sprachstandard ECMAScript 2024. Die Verfügbarkeit hängt davon ab, ob die Laufzeitumgebung die entsprechenden DOM-APIs bereitstellt.

Beispiele

<!doctype html>
<meta charset="utf-8">
<title>Node.contains() and Node.parentElement</title>
<script>
  const fragment = document.createDocumentFragment();
  const section = document.createElement("section");
  const span = document.createElement("span");
  const text = document.createTextNode("Hello");

  fragment.appendChild(section);
  section.appendChild(span);
  span.appendChild(text);

  console.log(`section.contains(text): ${section.contains(text)}`);
  console.log(`section.contains(section): ${section.contains(section)}`);
  console.log(`section.contains(null): ${section.contains(null)}`);
  console.log(`text.parentElement === span: ${text.parentElement === span}`);
  console.log(`section.parentElement: ${section.parentElement}`);
  console.log(`section.parentNode === fragment: ${section.parentNode === fragment}`);
</script>

Ergebnis

section.contains(text): true
section.contains(section): true
section.contains(null): false
text.parentElement === span: true
section.parentElement: null
section.parentNode === fragment: true

Speichere das Beispiel als `.html`-Datei, öffne sie im Browser und prüfe die Ausgabe in der Entwicklerkonsole. Das nicht mit dem Dokument verbundene Fragment enthält `section`, ist aber kein `Element`. Deshalb ist `section.parentElement` gleich `null`, obwohl `section.parentNode` das Fragment ist.

Zugehörige Lektionen

  • JavaScript · Lektion 18 · Fortgeschritten · Version: 4

Quellen