Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / JavaScript

Nœuds du DOM : type, valeur et nœuds enfants

Distinguez les nœuds texte des éléments, lisez la valeur d’un nœud et parcourez ses enfants directs en tenant compte des mises à jour de la liste.

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

Syntaxe

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

La propriété en lecture seule node.nodeType renvoie un entier qui indique le type du nœud. Comparez-le avec === aux constantes de l’interface Node : Node.TEXT_NODE (3) désigne un nœud texte, et Node.ELEMENT_NODE (1) un élément. Un élément et le texte qu’il contient sont des nœuds distincts. Ces API du DOM appartiennent à la plateforme web, pas à ECMAScript 2024 ; un environnement d’exécution JavaScript ne fournit pas nécessairement le DOM.

node.nodeValue concerne le nœud lui-même. Sur un nœud texte, elle donne accès à son texte ; lui affecter une chaîne remplace ce texte sans interpréter la chaîne comme du HTML. Un commentaire a lui aussi une valeur de type chaîne. Pour un élément, cette propriété renvoie null et une affectation reste sans effet, même si l’élément contient du texte. Utilisez element.textContent pour lire le texte cumulé de ses descendants, hors commentaires et instructions de traitement.

La propriété en lecture seule node.childNodes renvoie une NodeList dynamique des enfants directs, pas de tous les descendants. Ce n’est pas un tableau et ses indices commencent à zéro. Elle inclut les éléments, les nœuds texte et les commentaires. L’indentation et les sauts de ligne du HTML peuvent produire des nœuds texte composés uniquement d’espaces blancs : childNodes[0] n’est donc pas forcément un élément. Pour ne récupérer que les enfants directs de type élément, utilisez element.children.

Même si vous conservez une référence à la liste, les ajouts et suppressions d’enfants y apparaissent. Supprimer un nœud pendant un parcours dans l’ordre croissant peut décaler les indices et vous faire sauter le suivant. Pour parcourir une liste d’entrées fixe, utilisez Array.from(node.childNodes) avant les modifications. Le tableau contient des références aux mêmes nœuds, pas des clones.

Exemples

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

Résultat

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

Exécutez le code dans la console du navigateur sur une page HTML. La liste conservée passe de `0` à `2` même si le parent n’est pas rattaché à la page. La ligne JSON du nœud texte affiche une seule espace entre guillemets.

Leçons associées

  • JavaScript · Leçon 16 · Avancé · Version : 4

Sources