CKTIS / JavaScript
Esaminare e modificare i nodi del DOM con `Node`
Verifica se un nodo appartiene a un sottoalbero, leggi il suo genitore o il primo figlio, inserisci un nodo in una posizione precisa e unisci i nodi di testo adiacenti.
Versione: ECMAScript 2024 and the current web platform; runtime support varies
Sintassi
node.contains(otherNode)
node.normalize()
node.parentNode
node.firstChild
parent.insertBefore(newNode, referenceNode)
parent.insertBefore(newNode, null)Node è un’interfaccia del DOM del Web, non una funzionalità di ECMAScript 2024. Questi metodi e proprietà si usano sugli oggetti che rappresentano i nodi. Nel browser l’esempio usa il DOM nativo; in Node.js usa un modello semplificato degli elementi e dei nodi di testo mostrati.
node.contains(otherNode) restituisce true se otherNode è lo stesso nodo o un discendente a qualsiasi profondità. Per null restituisce false. Il controllo si limita allo stesso albero di nodi: funziona anche in un sottoalbero scollegato e non passa dall’host al suo albero shadow DOM.
parentNode e firstChild sono proprietà di sola lettura. La prima restituisce il nodo genitore diretto oppure null; a differenza di parentElement, può restituire un Document o un DocumentFragment. La seconda restituisce il primo figlio diretto oppure null. Il figlio può essere un commento o un nodo di testo con spazi bianchi. Per ottenere il primo elemento figlio, usa firstElementChild.
parent.insertBefore(newNode, referenceNode) inserisce il nodo prima del figlio diretto indicato. Passa esplicitamente il secondo argomento: null inserisce in coda. Usa parent.firstChild per inserire all’inizio anche quando il genitore è vuoto. Il metodo sposta un nodo esistente anziché copiarlo e restituisce newNode. Se riceve un DocumentFragment, ne sposta i figli e restituisce il frammento svuotato. Un nodo di riferimento che non è un figlio diretto causa NotFoundError; una gerarchia non valida, per esempio un ciclo, causa HierarchyRequestError.
node.normalize() modifica direttamente il sottoalbero: rimuove i nodi di testo ordinari vuoti e unisce quelli adiacenti rispettando l’ordine del testo. Non elimina gli spazi bianchi e restituisce undefined. Un riferimento conservato a un nodo rimosso punta ancora a quell’oggetto, che però non ha più un genitore. Non è la normalizzazione Unicode eseguita da String.prototype.normalize().
Esempi
{
// 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
]));
}Risultato
[true,false,true,true,true,3] [true,"AB",false,true,1]
Esegui il codice nella console del browser o con Node.js. `root` resta fuori dal documento. Dopo la normalizzazione, `a` contiene `AB` ed è l’unico figlio, mentre `b` è scollegato.
Lezioni correlate
- JavaScript · Lezione 33 · Intermedio · Versione: 3