Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / JavaScript

Nodos del DOM: tipo, valor y nodos hijos

Distingue los nodos de texto de los elementos, lee el valor de un nodo y recorre sus hijos directos teniendo en cuenta que la lista se actualiza.

Versión: ECMAScript 2024 and the current web platform; runtime support varies

Sintaxis

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

La propiedad de solo lectura node.nodeType devuelve un entero que identifica el tipo de nodo. Compáralo con === con las constantes de la interfaz Node: Node.TEXT_NODE (3) identifica un nodo de texto y Node.ELEMENT_NODE (1), un elemento. Un elemento y el texto que contiene son nodos distintos. Estas API del DOM pertenecen a la plataforma web, no a ECMAScript 2024; un entorno de ejecución de JavaScript no tiene por qué ofrecer el DOM.

node.nodeValue se refiere al propio nodo. En un nodo de texto, permite leer su texto, y asignarle una cadena sustituye ese texto sin interpretar la cadena como HTML. Un comentario también tiene un valor de tipo cadena. En un elemento, la propiedad devuelve null y asignarle un valor no tiene efecto, aunque el elemento contenga texto. Para leer el texto combinado de sus descendientes, sin comentarios ni instrucciones de procesamiento, usa element.textContent.

La propiedad de solo lectura node.childNodes proporciona una NodeList dinámica de los hijos directos, no de todos los descendientes. Sus índices empiezan en cero y no es un array. Incluye elementos, nodos de texto y comentarios. La sangría y los saltos de línea del HTML pueden generar nodos de texto que solo contienen espacios en blanco, de modo que childNodes[0] no tiene por qué ser un elemento. Si solo quieres los hijos directos que son elementos, usa element.children.

Si guardas una referencia a la lista, esta sigue reflejando las incorporaciones y eliminaciones de hijos. Eliminar un nodo al recorrerla hacia delante puede desplazar los índices y hacer que te saltes el siguiente. Si necesitas recorrer un conjunto fijo de entradas, usa Array.from(node.childNodes) antes de hacer cambios. El array contiene referencias a los mismos nodos, no copias.

Ejemplos

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

Resultado

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

Ejecuta el código en la consola del navegador en una página HTML. La lista guardada pasa de `0` a `2` aunque el nodo padre no esté conectado a la página. La línea JSON del nodo de texto muestra un solo espacio entre comillas.

Lecciones relacionadas

  • JavaScript · Lección 16 · Avanzado · Versión: 4

Fuentes