À propos de ce cours
Chapitre 12 — Le DOM : parcours et mise à jour · La classe Node du DOM
• comprendre que tout, dans le DOM, est un nœud (
Node) ;• connaître les principaux types de nœuds et la propriété
nodeType; • distinguer les nœuds éléments des nœuds texte, et
childNodes de children; • situer
Node dans la hiérarchie des classes du DOM.1. Tout est nœud
Dans l'arbre du DOM, chaque composant est un nœud (node) : le document lui-même, chaque balise,
chaque morceau de texte, chaque commentaire. Tous ces objets sont des instances de classes qui héritent d'une même classe de base,
Node. C'est elle qui fournit ce que tous les nœuds savent faire : connaître leur type, leur parent, leurs enfants.

Figure 1 — Un paragraphe est à la fois un HTMLParagraphElement, un HTMLElement, un Element et un Node.
2. Les types de nœuds
| Type | nodeType | nodeName | Exemple |
|---|---|---|---|
| Élément | 1 (Node.ELEMENT_NODE) | nom de la balise en majuscules : P, LI | <p>…</p> |
| Texte | 3 (Node.TEXT_NODE) | #text | le texte entre les balises, y compris les retours à la ligne |
| Commentaire | 8 (Node.COMMENT_NODE) | #comment | <!-- … --> |
| Document | 9 (Node.DOCUMENT_NODE) | #document | document |
| Fragment | 11 (Node.DOCUMENT_FRAGMENT_NODE) | #document-fragment | un conteneur temporaire (leçon 12.8) |
📄 l2_node.html
<!DOCTYPE html>
<html lang="fr">
<head><meta charset="UTF-8"><link rel="stylesheet" href="style.css"></head>
<body>
<p id="phrase">Bonjour <strong>le monde</strong> !<!-- un commentaire --></p>
<pre id="sortie"></pre>
<script>
const p = document.querySelector("#phrase");
const lignes = [];
lignes.push(`p.nodeType = ${p.nodeType} (Node.ELEMENT_NODE = ${Node.ELEMENT_NODE})`);
lignes.push(`p.nodeName = ${p.nodeName}`);
lignes.push(`p.childNodes.length = ${p.childNodes.length} | p.children.length = ${p.children.length}`);
lignes.push("");
lignes.push("Les nœuds enfants du paragraphe :");
p.childNodes.forEach((n, i) => {
const valeur = n.nodeValue === null ? "null" : JSON.stringify(n.nodeValue);
lignes.push(` [${i}] nodeType=${n.nodeType} nodeName=${n.nodeName.padEnd(9)} nodeValue=${valeur}`);
});
lignes.push("");
lignes.push(`p.firstChild.nodeName = ${p.firstChild.nodeName}`);
lignes.push(`p.textContent = ${JSON.stringify(p.textContent)}`);
lignes.push(`p instanceof Node ? ${p instanceof Node} | HTMLElement ? ${p instanceof HTMLElement}`);
lignes.push(`Chaîne des prototypes : ${chaine(p)}`);
function chaine(o) {
const noms = [];
for (let x = Object.getPrototypeOf(o); x; x = Object.getPrototypeOf(x)) noms.push(x.constructor.name);
return noms.join(" → ");
}
document.querySelector("#sortie").textContent = lignes.join("\n");
</script>
</body>
</html>

Les nœuds d'un paragraphe
Le paragraphe a 4 nœuds enfants (childNodes) mais un seul élément enfant (children) :
le texte « Bonjour », le <strong>, le texte « ! » et le commentaire. Les propriétés utiles :
nodeType,nodeName: le type et le nom du nœud ;nodeValue: le texte d'un nœud texte ou commentaire (nullpour un élément) ;textContent: tout le texte contenu dans le nœud et ses descendants ;parentNode,childNodes,firstChild,lastChild,previousSibling,nextSibling: les liens de parenté (leçon 12.5) ;hasChildNodes(),contains(autreNoeud): des tests utiles.
3. Et les attributs ?
Les attributs (href, class, id…) sont représentés par des objets Attr, mais ils ne font
pas partie de l'arbre: ils ne sont ni parents ni enfants d'aucun nœud. On les lit et on les modifie à partir de l'élément,
avec getAttribute et setAttribute (leçon 12.6).
Cette leçon a été mise à jour. L'ancienne version présentait les attributs comme des « nœuds attributs » de l'arbre : ce n'est plus le cas dans le DOM actuel. La partie sur les nœuds parents citait
OnParentChanged et l'événement ParentChanged: ces noms n'existent pas en JavaScript (ils proviennent d'une autre bibliothèque). Pour réagir aux changements de l'arbre, le DOM propose
MutationObserver, une notion avancée.• Tout composant du DOM est un nœud ; tous héritent de la classe
Node. •
nodeType: 1 = élément, 3 = texte, 8 = commentaire, 9 = document.•
childNodes contient tous les nœuds (textes compris) ; children seulement les éléments.• Les attributs ne sont pas des nœuds de l'arbre : on y accède par l'élément.
🛠 Activité 2 — Disséquer un paragraphe
Mission : Écrivez un petit outil qui affiche, pour n'importe quel élément de votre page, la liste de ses nœuds enfants avec leur type.
Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :
- Écrivez un paragraphe avec du texte, un lien et un commentaire. Avant d'exécuter quoi que ce soit, prédisez la valeur de
childNodes.lengthet dechildren.length. Vérifiez dans la console. - Ajoutez un retour à la ligne et des espaces entre deux balises dans votre HTML. Combien de nœuds de plus apparaissent ? De quel type ?
- Écrivez une fonction
decrire(element)qui affiche, pour chaque nœud enfant, sonnodeType, sonnodeNameet sonnodeValue. Pourquoi est-il plus lisible de comparer avecNode.TEXT_NODEqu'avec le nombre 3 ? - Modifiez la fonction pour qu'elle ignore les nœuds texte vides (seulement des espaces). Quelle méthode de chaîne utilisez-vous ?
- Testez
p instanceof Node,p instanceof Elementetp.firstChild instanceof Element. Expliquez les résultats à l'aide de la figure 1. - Que renvoie
document.body.contains(p)? Et après avoir exécutép.remove()?
Je vérifie / je rends :
- ☐ Votre fonction
decrireet vos prédictions comparées aux résultats.
← Présentation et historique du DOML'accès aux éléments HTML en JavaScript →
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !