KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

DOM-nodes inspecteren en wijzigen met `Node`

Test of een node bij een deelboom hoort, lees de ouder of het eerste kind uit, voeg een node op een bepaalde plek in en voeg aangrenzende tekstnodes samen.

Versie: 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 is een interface van het web-DOM en maakt geen deel uit van ECMAScript 2024. Je gebruikt deze methoden en eigenschappen op node-objecten. In een browser gebruikt het voorbeeld het ingebouwde DOM; in Node.js gebruikt het een vereenvoudigd model van de getoonde element- en tekstnodes.

node.contains(otherNode) geeft true terug als otherNode dezelfde node is of een afstammeling op ongeacht welke diepte. Voor null geeft de methode false terug. De test blijft binnen dezelfde nodeboom: hij werkt in een losgekoppelde deelboom en gaat niet van de host naar zijn shadow tree.

parentNode en firstChild zijn alleen-lezen-eigenschappen. De eerste geeft de directe ouder of null terug. Anders dan parentElement kan deze ook een Document of DocumentFragment teruggeven. De tweede geeft het eerste directe kind of null terug. Dat kan ook een commentaarnode of een tekstnode met witruimte zijn. Gebruik firstElementChild voor het eerste kind dat een element is.

parent.insertBefore(newNode, referenceNode) voegt een node in vóór het opgegeven directe kind. Geef het tweede argument expliciet mee: null voegt achteraan in. Met parent.firstChild voeg je dus vooraan in, ook als de ouder leeg is. De methode verplaatst een bestaande node in plaats van die te kopiëren en retourneert newNode. Voor een DocumentFragment verplaatst ze de kinderen en retourneert ze het geleegde fragment. Is de referentienode geen direct kind, dan volgt NotFoundError; een ongeldige hiërarchie, zoals een cyclus, leidt tot HierarchyRequestError.

node.normalize() wijzigt de deelboom zelf: de methode verwijdert lege gewone tekstnodes en voegt aangrenzende tekstnodes van dat type samen in tekstvolgorde. Ze verwijdert geen witruimte en retourneert undefined. Een bewaarde referentie naar een verwijderde node wijst nog steeds naar dat object, maar het heeft geen ouder meer. Dit is niet de Unicode-normalisatie van String.prototype.normalize().

Voorbeelden

{
  // 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
  ]));
}

Resultaat

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

Voer dit uit in de browserconsole of met Node.js. `root` blijft buiten het document. Na normalisatie bevat `a` de tekst `AB` en is het het enige kind; `b` is losgekoppeld.

Gerelateerde lessen

  • JavaScript · Les 33 · Gemiddeld · Versie: 3

Bronnen