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

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-only

container.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

Sources