WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / JavaScript

DOM-Knoten mit `Node` untersuchen und ändern

Prüfe, ob ein Knoten zu einem Teilbaum gehört, lies seinen Elternknoten oder sein erstes Kind aus, füge einen Knoten gezielt ein und führe benachbarte Textknoten zusammen.

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

Syntax

node.contains(otherNode)
node.normalize()
node.parentNode
node.firstChild
parent.insertBefore(newNode, referenceNode)
parent.insertBefore(newNode, null)

Node ist eine Schnittstelle des Web-DOM und nicht Teil von ECMAScript 2024. Die Methoden und Eigenschaften werden an Knotenobjekten verwendet. Im Browser nutzt das Beispiel das native DOM, in Node.js ein vereinfachtes Modell der verwendeten Element- und Textknoten.

node.contains(otherNode) gibt true zurück, wenn otherNode derselbe Knoten oder ein Nachfahre in beliebiger Tiefe ist. Bei null liefert die Methode false. Geprüft wird innerhalb desselben Knotenbaums: Das funktioniert auch in einem vom Dokument getrennten Teilbaum; vom Host aus wird sein Shadow-Baum nicht einbezogen.

parentNode und firstChild sind schreibgeschützte Eigenschaften. Die erste liefert den unmittelbaren Elternknoten oder null. Anders als parentElement kann sie auch ein Document oder DocumentFragment liefern. Die zweite liefert das erste direkte Kind oder null. Das Kind kann auch ein Kommentar oder ein Textknoten mit Leerraum sein. Für das erste Kindelement verwende firstElementChild.

parent.insertBefore(newNode, referenceNode) fügt den Knoten vor dem angegebenen direkten Kind ein. Gib das zweite Argument ausdrücklich an: null fügt am Ende ein. Mit parent.firstChild fügst du damit auch bei einem leeren Elternknoten am Anfang ein. Die Methode verschiebt einen vorhandenen Knoten, statt ihn zu kopieren, und gibt newNode zurück. Bei einem DocumentFragment verschiebt sie dessen Kinder und gibt das geleerte Fragment zurück. Ist der Referenzknoten kein direktes Kind, wird NotFoundError ausgelöst; eine unzulässige Hierarchie, etwa ein Zyklus, löst HierarchyRequestError aus.

node.normalize() verändert den Teilbaum direkt: Die Methode entfernt leere gewöhnliche Textknoten und führt benachbarte Knoten dieses Typs in Textreihenfolge zusammen. Sie entfernt keinen Leerraum und gibt undefined zurück. Eine gespeicherte Referenz auf einen entfernten Knoten zeigt weiterhin auf dieses Objekt, das aber keinen Elternknoten mehr hat. Das ist keine Unicode-Normalisierung wie bei String.prototype.normalize().

Beispiele

{
  // Node.js has no document. This fallback models only the element and
  // text-node behavior used below; in a browser, use the native DOM.
  class ExampleNode {
    parentNode = null;
    childNodes = [];

    constructor(data = null) {
      this.data = data;
    }

    get firstChild() {
      return this.childNodes[0] ?? null;
    }

    contains(node) {
      for (let current = node; current !== null; current = current.parentNode) {
        if (current === this) return true;
      }
      return false;
    }

    #detach() {
      const parent = this.parentNode;
      if (parent !== null) {
        parent.childNodes.splice(parent.childNodes.indexOf(this), 1);
        this.parentNode = null;
      }
    }

    insertBefore(node, reference) {
      if (node === reference) return node;
      node.#detach();
      const index = reference === null
        ? this.childNodes.length
        : this.childNodes.indexOf(reference);
      this.childNodes.splice(index, 0, node);
      node.parentNode = this;
      return node;
    }

    normalize() {
      let previousText = null;
      for (const child of [...this.childNodes]) {
        if (child.data === null) {
          child.normalize();
          previousText = null;
        } else if (child.data === "") {
          child.#detach();
        } else if (previousText !== null) {
          previousText.data += child.data;
          child.#detach();
        } else {
          previousText = child;
        }
      }
    }
  }

  const doc = globalThis.document ?? {
    createElement: () => new ExampleNode(),
    createTextNode: (data) => new ExampleNode(data)
  };
  const root = doc.createElement("div");
  const a = doc.createTextNode("A");
  const b = doc.createTextNode("B");
  const empty = doc.createTextNode("");

  root.insertBefore(a, root.firstChild);
  root.insertBefore(b, null);
  root.insertBefore(empty, root.firstChild);
  console.log(JSON.stringify([
    root.contains(root), root.contains(null), root.contains(b),
    b.parentNode === root, root.firstChild === empty, root.childNodes.length
  ]));

  root.normalize();
  console.log(JSON.stringify([
    root.firstChild === a, root.firstChild.data, root.contains(b),
    b.parentNode === null, root.childNodes.length
  ]));
}

Ergebnis

[true,false,true,true,true,3]
[true,"AB",false,true,1]

Führe den Code in der Browserkonsole oder mit Node.js aus. `root` bleibt außerhalb des Dokuments. Nach der Normalisierung enthält `a` den Text `AB` und ist das einzige Kind; `b` ist nicht mehr im Teilbaum.

Zugehörige Lektionen

  • JavaScript · Lektion 33 · Mittlere Stufe · Version: 3

Quellen