CKTIS / JavaScript
Inspecionar e modificar nós do DOM com `Node`
Verifica se um nó pertence a uma subárvore, consulta o nó pai ou o primeiro filho, insere um nó numa posição específica e junta nós de texto adjacentes.
Versão: ECMAScript 2024 and the current web platform; runtime support varies
Sintaxe
node.contains(otherNode)
node.normalize()
node.parentNode
node.firstChild
parent.insertBefore(newNode, referenceNode)
parent.insertBefore(newNode, null)Node é uma interface do DOM da Web, não uma funcionalidade do ECMAScript 2024. Estes métodos e propriedades são usados em objetos que representam nós. Num navegador, o exemplo usa o DOM nativo; em Node.js, usa um modelo simplificado dos elementos e nós de texto apresentados.
node.contains(otherNode) devolve true se otherNode for o próprio nó ou um descendente a qualquer profundidade. Para null, devolve false. O teste fica limitado à mesma árvore de nós: funciona numa subárvore desligada e não passa do anfitrião para a respetiva árvore shadow DOM.
parentNode e firstChild são propriedades só de leitura. A primeira devolve o nó pai direto ou null; ao contrário de parentElement, pode devolver um Document ou um DocumentFragment. A segunda devolve o primeiro filho direto ou null. Esse filho pode ser um comentário ou um nó de texto com espaços em branco. Para obter o primeiro elemento filho, usa firstElementChild.
parent.insertBefore(newNode, referenceNode) insere o nó antes do filho direto indicado. Passa explicitamente o segundo argumento: null insere no fim. Assim, parent.firstChild permite inserir no início mesmo quando o nó pai está vazio. O método move um nó existente em vez de o copiar e devolve newNode. Se receber um DocumentFragment, move os filhos do fragmento e devolve o fragmento vazio. Se o nó de referência não for um filho direto, lança NotFoundError; uma hierarquia inválida, como um ciclo, provoca HierarchyRequestError.
node.normalize() altera a própria subárvore: remove nós de texto comuns vazios e junta os que estão lado a lado, mantendo a ordem do texto. Não elimina espaços em branco e devolve undefined. Uma referência guardada para um nó removido continua a apontar para esse objeto, mas o nó deixa de ter pai. Não se trata da normalização Unicode de String.prototype.normalize().
Exemplos
{
// 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
]));
}Resultado
[true,false,true,true,true,3] [true,"AB",false,true,1]
Executa o código na consola de um navegador ou com Node.js. `root` permanece fora do documento. Após a normalização, `a` contém `AB` e é o único filho, enquanto `b` fica desligado.
Lições relacionadas
- JavaScript · Lição 33 · Intermédio · Versão: 3