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