CKTIS / JavaScript
`contains()` et `parentElement` : descendants et parents directs dans le DOM
`contains()` vérifie si un nœud est le même nœud ou l’un de ses descendants. `parentElement` renvoie le parent direct uniquement si celui-ci est un élément.
Version : ECMAScript 2024 and the current web platform; runtime support varies
Syntaxe
container.contains(otherNode) // boolean; pass a Node or null
node.parentElement // Element or null; read-onlycontainer.contains(otherNode) renvoie true si otherNode est container lui-même ou un descendant à n’importe quelle profondeur, y compris un nœud texte. Avec null, la méthode renvoie false. Omettre l’argument obligatoire ou passer une chaîne déclenche une TypeError. Pour exclure container lui-même, utilisez otherNode !== container && container.contains(otherNode).
node.parentElement est une propriété en lecture seule, pas une méthode. Elle renvoie le parent direct s’il s’agit d’un Element. Elle renvoie null en l’absence de parent ou si le parent est d’un autre type, par exemple Document ou DocumentFragment. Elle ne remonte pas plus haut dans l’arbre. Pour obtenir le parent direct quel que soit son type, utilisez node.parentNode.
Les deux opérations reflètent la structure actuelle de l’arbre, même si celui-ci est détaché du document. Déplacer un nœud peut modifier le résultat. Aucune des deux ne passe d’un arbre shadow à son hôte : pour contains(), l’hôte ne contient pas les nœuds de son arbre shadow, et pour un enfant direct d’un ShadowRoot, parentElement vaut null.
Ces membres appartiennent à l’interface Node du DOM et non au langage ECMAScript 2024. Leur disponibilité dépend de la prise en charge des API DOM correspondantes par l’environnement d’exécution.
Exemples
<!doctype html>
<meta charset="utf-8">
<title>Node.contains() and Node.parentElement</title>
<script>
const fragment = document.createDocumentFragment();
const section = document.createElement("section");
const span = document.createElement("span");
const text = document.createTextNode("Hello");
fragment.appendChild(section);
section.appendChild(span);
span.appendChild(text);
console.log(`section.contains(text): ${section.contains(text)}`);
console.log(`section.contains(section): ${section.contains(section)}`);
console.log(`section.contains(null): ${section.contains(null)}`);
console.log(`text.parentElement === span: ${text.parentElement === span}`);
console.log(`section.parentElement: ${section.parentElement}`);
console.log(`section.parentNode === fragment: ${section.parentNode === fragment}`);
</script>Résultat
section.contains(text): true section.contains(section): true section.contains(null): false text.parentElement === span: true section.parentElement: null section.parentNode === fragment: true
Enregistrez l’exemple dans un fichier `.html`, ouvrez-le dans un navigateur et vérifiez le résultat dans la console de développement. Le fragment détaché contient `section` sans être un `Element`. Ainsi, `section.parentElement` vaut `null`, alors que `section.parentNode` est le fragment.
Leçons associées
- JavaScript · Leçon 18 · Avancé · Version : 4