CKTIS / JavaScript
Examiner et modifier les nœuds du DOM avec `Node`
Vérifiez si un nœud appartient à un sous-arbre, récupérez son parent ou son premier enfant, insérez un nœud à un emplacement précis et fusionnez les nœuds texte adjacents.
Version : ECMAScript 2024 and the current web platform; runtime support varies
Syntaxe
node.contains(otherNode)
node.normalize()
node.parentNode
node.firstChild
parent.insertBefore(newNode, referenceNode)
parent.insertBefore(newNode, null)Node est une interface du DOM du Web, et non une fonctionnalité d’ECMAScript 2024. Ces méthodes et propriétés s’utilisent sur des objets représentant des nœuds. Dans un navigateur, l’exemple utilise le DOM natif ; dans Node.js, il utilise un modèle simplifié des éléments et des nœuds texte de l’exemple.
node.contains(otherNode) renvoie true si otherNode est le même nœud ou un descendant à n’importe quelle profondeur. La méthode renvoie false pour null. Le test reste dans le même arbre de nœuds : il fonctionne dans un sous-arbre détaché et ne passe pas de l’hôte à son arbre shadow DOM.
parentNode et firstChild sont des propriétés en lecture seule. La première renvoie le parent direct ou null ; contrairement à parentElement, elle peut renvoyer un Document ou un DocumentFragment. La seconde renvoie le premier enfant direct ou null. Cet enfant peut être un commentaire ou un nœud texte contenant des espaces blancs. Pour obtenir le premier élément enfant, utilisez firstElementChild.
parent.insertBefore(newNode, referenceNode) insère le nœud avant l’enfant direct indiqué. Passez explicitement le second argument : null insère à la fin. Utiliser parent.firstChild permet donc d’insérer au début, même si le parent est vide. La méthode déplace un nœud existant au lieu de le copier et renvoie newNode. Pour un DocumentFragment, elle déplace ses enfants et renvoie le fragment vidé. Un nœud de référence qui n’est pas un enfant direct provoque NotFoundError ; une hiérarchie non valide, par exemple un cycle, provoque HierarchyRequestError.
node.normalize() modifie le sous-arbre sur place : la méthode supprime les nœuds texte ordinaires vides et fusionne ceux qui se suivent, en conservant l’ordre du texte. Elle ne supprime pas les espaces blancs et renvoie undefined. Une référence conservée vers un nœud retiré désigne toujours cet objet, mais celui-ci n’a plus de parent. Ce n’est pas la normalisation Unicode effectuée par String.prototype.normalize().
Exemples
{
// 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
]));
}Résultat
[true,false,true,true,true,3] [true,"AB",false,true,1]
Exécutez le code dans la console d’un navigateur ou avec Node.js. `root` reste hors du document. Après la normalisation, `a` contient `AB` et est le seul enfant, tandis que `b` est détaché.
Leçons associées
- JavaScript · Leçon 33 · Intermédiaire · Version : 3