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

CKTIS / JavaScript

Inspección y modificación de nodos del DOM con `Node`

Comprueba si un nodo pertenece a un subárbol, consulta su padre o su primer hijo, inserta un nodo en una posición concreta y fusiona nodos de texto contiguos.

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

Sintaxis

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

Node es una interfaz del DOM web, no una característica de ECMAScript 2024. Usa estos métodos y propiedades sobre objetos que representan nodos. En un navegador, el ejemplo usa el DOM nativo; en Node.js, usa un modelo simplificado de los elementos y nodos de texto que muestra.

node.contains(otherNode) devuelve true si otherNode es el mismo nodo o un descendiente a cualquier profundidad. Devuelve false para null. La comprobación se limita al mismo árbol de nodos: funciona en un subárbol desconectado y no pasa del anfitrión a su árbol shadow DOM.

parentNode y firstChild son propiedades de solo lectura. La primera devuelve el padre inmediato o null; a diferencia de parentElement, puede devolver un Document o un DocumentFragment. La segunda devuelve el primer hijo directo o null. Ese hijo puede ser un comentario o un nodo de texto con espacios en blanco. Para obtener el primer elemento hijo, usa firstElementChild.

parent.insertBefore(newNode, referenceNode) inserta el nodo antes del hijo directo indicado. Pasa el segundo argumento de forma explícita: null inserta al final. Usar parent.firstChild permite insertar al principio incluso si el padre está vacío. El método mueve un nodo existente en lugar de copiarlo y devuelve newNode. Si recibe un DocumentFragment, mueve sus hijos y devuelve el fragmento vacío. Si el nodo de referencia no es un hijo directo, lanza NotFoundError; una jerarquía inválida, como un ciclo, provoca HierarchyRequestError.

node.normalize() modifica el subárbol en el sitio: elimina los nodos de texto ordinarios vacíos y fusiona los contiguos respetando el orden del texto. No elimina espacios en blanco y devuelve undefined. Una referencia guardada a un nodo retirado sigue apuntando a ese objeto, pero este ya no tiene padre. Esto no es la normalización Unicode de String.prototype.normalize().

Ejemplos

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

Resultado

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

Ejecuta el código en la consola de un navegador o con Node.js. `root` permanece fuera del documento. Tras la normalización, `a` contiene `AB` y es el único hijo, mientras que `b` queda desconectado.

Lecciones relacionadas

  • JavaScript · Lección 33 · Intermedio · Versión: 3

Fuentes