Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

`contains()` e `parentElement`: discendenti e genitori diretti nel DOM

`contains()` verifica se un nodo coincide con un altro nodo o ne è un discendente. `parentElement` restituisce il genitore diretto solo se è un elemento.

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

Sintassi

container.contains(otherNode) // boolean; pass a Node or null
node.parentElement            // Element or null; read-only

container.contains(otherNode) restituisce true se otherNode è container stesso o un suo discendente a qualsiasi profondità, anche un nodo di testo. Se passi null, restituisce false. Omettere l’argomento obbligatorio o passare una stringa genera un TypeError. Per escludere container stesso, usa otherNode !== container && container.contains(otherNode).

node.parentElement è una proprietà di sola lettura, non un metodo. Restituisce il genitore diretto se è un Element. Restituisce null se non c’è un genitore o se è di un altro tipo, come Document o DocumentFragment. Non risale oltre nell’albero. Per ottenere il genitore diretto a prescindere dal tipo, usa node.parentNode.

Entrambe le operazioni riflettono la struttura attuale dell’albero, anche se è scollegato dal documento. Spostare un nodo può cambiare il risultato. Nessuna delle due passa dallo shadow tree al suo host: per contains(), l’host non contiene i nodi del suo shadow tree, e per un figlio diretto di uno ShadowRoot, parentElement vale null.

Questi membri fanno parte dell’interfaccia Node del DOM, non del linguaggio ECMAScript 2024. La loro disponibilità dipende dal fatto che l’ambiente di esecuzione fornisca le API DOM corrispondenti.

Esempi

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

Risultato

section.contains(text): true
section.contains(section): true
section.contains(null): false
text.parentElement === span: true
section.parentElement: null
section.parentNode === fragment: true

Salva l’esempio come file `.html`, aprilo in un browser e controlla l’output nella console per sviluppatori. Il frammento scollegato contiene `section`, ma non è un `Element`. Quindi `section.parentElement` vale `null`, anche se `section.parentNode` è il frammento.

Lezioni correlate

  • JavaScript · Lezione 18 · Avanzato · Versione: 4

Fonti