Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

Nodi del DOM: tipo, valore e nodi figli

Distingui i nodi di testo dagli elementi, leggi il valore di un singolo nodo e scorri i figli diretti tenendo conto degli aggiornamenti della lista.

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

Sintassi

node.nodeType
node.nodeValue
node.nodeValue = text
node.childNodes
node.nodeType === Node.TEXT_NODE
node.nodeType === Node.ELEMENT_NODE

La proprietà di sola lettura node.nodeType restituisce un intero che identifica il tipo di nodo. Confrontalo tramite === con le costanti dell’interfaccia Node: Node.TEXT_NODE (3) identifica un nodo di testo, mentre Node.ELEMENT_NODE (1) identifica un elemento. Un elemento e il testo che contiene sono nodi distinti. Queste API del DOM appartengono alla piattaforma web, non a ECMAScript 2024: un ambiente di esecuzione JavaScript non deve necessariamente fornire il DOM.

node.nodeValue riguarda il nodo stesso. Su un nodo di testo permette di leggere il testo; assegnarle una stringa sostituisce il testo senza interpretare la stringa come HTML. Anche un commento ha un valore di tipo stringa. Su un elemento, la proprietà restituisce null e un’assegnazione non ha effetto, anche se l’elemento contiene testo. Per leggere il testo complessivo dei suoi discendenti, esclusi commenti e istruzioni di elaborazione, usa element.textContent.

La proprietà di sola lettura node.childNodes restituisce una NodeList dinamica dei figli diretti, non di tutti i discendenti. Gli indici partono da zero e la lista non è un array. Include elementi, nodi di testo e commenti. I rientri e le interruzioni di riga nell’HTML possono produrre nodi di testo composti soltanto da caratteri di spaziatura; quindi childNodes[0] non è necessariamente un elemento. Se ti servono solo i figli diretti di tipo elemento, usa element.children.

Anche se conservi un riferimento alla lista, questa continua a riflettere aggiunte e rimozioni di figli. Rimuovere un nodo mentre scorri la lista in avanti può spostare gli indici e farti saltare il nodo successivo. Se ti serve un insieme stabile di voci su cui iterare, usa Array.from(node.childNodes) prima delle modifiche. L’array contiene riferimenti agli stessi nodi, non cloni.

Esempi

{
  const { document, Node } = globalThis.document && globalThis.Node
    ? globalThis
    : createExampleDOM();

  const parent = document.createElement("div");
  const children = parent.childNodes;
  console.log(children.length);

  const text = document.createTextNode(" ");
  const span = document.createElement("span");
  span.appendChild(document.createTextNode("inside"));
  parent.appendChild(text);
  parent.appendChild(span);
  console.log(children.length);

  for (const child of children) {
    const type = child.nodeType;
    const kind = type === Node.TEXT_NODE ? "text" :
      type === Node.ELEMENT_NODE ? "element" : "other";
    console.log(JSON.stringify([kind, type, child.nodeValue]));
  }

  span.nodeValue = "ignored";
  console.log(span.textContent);
  text.nodeValue = "outside";
  console.log(text.nodeValue);

  // Plain Node.js has no DOM. This local model implements only the
  // element, text, and live-list operations used by this example.
  function createExampleDOM() {
    class ExampleNode {
      static TEXT_NODE = 3;
      static ELEMENT_NODE = 1;

      #type;
      #value;
      #children = [];
      #list;

      constructor(type, value = null) {
        this.#type = type;
        this.#value = value;
        const children = this.#children;
        this.#list = {
          get length() { return children.length; },
          [Symbol.iterator]() { return children[Symbol.iterator](); }
        };
      }

      get nodeType() { return this.#type; }
      get childNodes() { return this.#list; }
      get nodeValue() { return this.#value; }
      set nodeValue(value) {
        if (this.#type === ExampleNode.TEXT_NODE) {
          this.#value = value === null ? "" : String(value);
        }
      }

      get textContent() {
        if (this.#type === ExampleNode.TEXT_NODE) return this.#value;
        return this.#children.map(child => child.textContent).join("");
      }

      appendChild(child) {
        this.#children.push(child);
        return child;
      }
    }

    return {
      Node: ExampleNode,
      document: {
        createElement: () => new ExampleNode(ExampleNode.ELEMENT_NODE),
        createTextNode: value => new ExampleNode(ExampleNode.TEXT_NODE, String(value))
      }
    };
  }
}

Risultato

0
2
["text",3," "]
["element",1,null]
inside
outside

Esegui il codice nella console del browser su una pagina HTML. La lista conservata passa da `0` a `2` anche se il nodo padre non è collegato alla pagina. La riga JSON del nodo di testo mostra un solo spazio tra virgolette.

Lezioni correlate

  • JavaScript · Lezione 16 · Avanzato · Versione: 4

Fonti