Manipulação de Texto e Marcação: textContent, innerText e os Riscos de Segurança do innerHTML
Inicie o Módulo 2 dominando as três propriedades centrais de leitura e escrita de conteúdo no DOM: compreenda as diferenças fundamentais de comportamento, performance e cálculo de layout entre textContent e innerText, e descubra os graves riscos de segurança por injeção de scripts (XSS) e destruição de event listeners provocados pelo uso negligente de innerHTML.
📑 Índice do Conteúdo
1. A Tríade de Conteúdo no DOM
Quando precisamos ler ou atualizar o interior de uma caixa na tela, o JavaScript nos oferece três propriedades aparentemente similares, mas cujos comportamentos internos de engenharia diferem drasticamente:
element.textContent:Representa o conteúdo de texto bruto de um nó e de todos os seus descendentes.element.innerText:Representa o texto renderizado visível, respeitando as regras visuais do CSS.element.innerHTML:Representa a marcação HTML interna serializada como uma string viva.
2. `textContent`: Velocidade Pura e Segurança Imutável
Padronizado pela W3C no DOM Level 3, o textContent é a escolha padrão recomendada para manipulação de texto em aplicações profissionais.
- Cego ao CSS (Sem Reflow): O
textContentlê os nós de texto diretamente da árvore do DOM, ignorando completamente se o elemento possuidisplay: noneouvisibility: hidden. Como ele não precisa consultar a Render Tree, sua leitura é extremamente rápida e nunca dispara recálculos geométricos de layout. - Imunidade Total contra XSS: Quando você atribui uma string contendo tags HTML (ex:
caixa.textContent = "<b>Olá</b>"), o navegador não faz o parse da marcação. Os caracteres<e>são tratados como texto literal. Nenhum script malicioso consegue ser executado!
3. `innerText`: O Texto Consciente da Render Tree
Criado originalmente pela Microsoft no Internet Explorer e posteriormente padronizado no HTML5, o innerText aproxima-se do que o usuário humano realmente enxergaria e selecionaria com o cursor do mouse na tela.
Para determinar o que está visível, o
innerText força o navegador a calcular o Layout (Reflow) e consultar a Render Tree. Ele ignora elementos ocultos por display: none e reflete transformações como text-transform: uppercase. Se você ler innerText repetidamente dentro de um loop com centenas de elementos, causará o terrível gargalo de Layout Thrashing, congelando a interface.
4. `innerHTML`: O Poder da Marcação e a Brecha de XSS
A propriedade innerHTML permite ler ou injetar diretamente fragmentos inteiros de código HTML com tags, atributos e elementos aninhados.
Apesar de muito conveniente, seu uso exige cautela extrema devido a dois problemas graves de arquitetura:
1. Vulnerabilidades Críticas de Segurança (Cross-Site Scripting – XSS)
Se você concatenar dados fornecidos pelo usuário final (vindos de formulários, parâmetros de URL ou bancos de dados) diretamente no innerHTML, um invasor poderá injetar scripts maliciosos:
// ❌ VULNERABILIDADE GRAVE DE XSS:
const buscaUsuario = '<img src="x" onerror="alert('XSS Injetado!');">';
// O navegador executará o código malicioso imediatamente!
document.getElementById("resultado").innerHTML = `Resultados para: ${buscaUsuario}`;
2. Destruição Silenciosa de Event Listeners
Ao realizar uma concatenação ingênua com container.innerHTML += "<div>Novo Item</div>", o navegador destrói completamente todos os nós filhos existentes e recria novos nós a partir do texto HTML. Como consequência, todos os ouvintes de eventos (addEventListener) registrados anteriormente nos elementos filhos são sumariamente destruídos e perdidos na memória!
5. Quadro Comparativo de Decisão
| Característica | textContent | innerText | innerHTML |
|---|---|---|---|
| Lê elementos ocultos (`display: none`)? | Sim (lê todos os nós). | Não (apenas visíveis). | Sim (como código HTML). |
| Força recálculo de Layout (Reflow)? | Não (altíssima velocidade). | Sim (custo computacional). | Sim (dispara parsing). |
| Interpreta tags HTML? | Não (texto literal seguro). | Não (texto puro). | Sim (cria elementos reais). |
| Segurança nativa contra XSS? | 🛡️ 100% Seguro. | 🛡️ 100% Seguro. | 🚨 Alto Risco sem sanitização. |
comparando-texto-e-html.js
// =====================================================================
// LAB: DIFERENÇAS PRÁTICAS ENTRE TEXTCONTENT, INNERTEXT E INNERHTML
// =====================================================================
console.log("=== LABORATÓRIO DE MANIPULAÇÃO DE CONTEÚDO NO DOM ===");
// 1. Criando elemento com nós mistos e estilos de visibilidade
const card = document.createElement("div");
card.id = "card-demo";
card.innerHTML = `
<h3>Artigo de <span style="text-transform: uppercase;">tecnologia</span></h3>
<p>
Este é um parágrafo visível.
<span style="display: none;">[TEXTO OCULTO VIA CSS]</span>
</p>
<script>var segredo = 123;</script>
`;
document.body.appendChild(card);
// 2. Comparando a leitura de textContent vs innerText vs innerHTML
console.log("n--- LEITURA DE CONTEÚDO ---");
console.log("1. textContent (Lê tudo, inclusive o texto oculto e o script):");
console.log(JSON.stringify(card.textContent));
console.log("n2. innerText (Consciente do CSS: ignora o display:none e reflete maiúsculas):");
console.log(JSON.stringify(card.innerText));
console.log("n3. innerHTML (Retorna a marcação bruta serializada):");
console.log(card.innerHTML.trim());
// 3. Teste de Escrita: Segurança e Injeção
const painelSeguranca = document.createElement("div");
document.body.appendChild(painelSeguranca);
const inputSuspeito = '<strong>Alerta:</strong> <script>console.log("Ataque!");</script>';
console.log("n--- TESTE DE ESCRITA E ESCAPE ---");
// Com textContent: 100% seguro contra injeção de tags!
painelSeguranca.textContent = inputSuspeito;
console.log("Escrita com textContent no DOM:", painelSeguranca.innerHTML);
// Resultado: <strong>Alerta:</strong> ... (escapado como entidade de texto!)
// 4. Demonstração da perda de Event Listeners com innerHTML +=
const botaoTeste = document.createElement("button");
botaoTeste.id = "btn-ouvinte";
botaoTeste.textContent = "Clique-me!";
botaoTeste.addEventListener("click", () => console.log("Botão clicado!"));
const containerBotoes = document.createElement("div");
containerBotoes.appendChild(botaoTeste);
document.body.appendChild(containerBotoes);
console.log("n--- TESTE DE DESTRUIÇÃO DE LISTENERS ---");
console.log("Antes do innerHTML +=: O botão possui ouvinte ativo.");
// Concatenando via innerHTML (Destrói e recria todos os nós!)
containerBotoes.innerHTML += ' (Novo Aviso)';
console.log("Após o innerHTML +=: O botão foi recriado como um novo objeto em memória!");
const botaoRecriado = document.getElementById("btn-ouvinte");
console.log("O botão em memória é o mesmo de antes?", botaoTeste === botaoRecriado); // FALSE!
console.log("Os ouvintes foram desanexados e perdidos!");
Aplique o que você aprendeu nesta lição
Utilize nossas ferramentas online gratuitas para experimentar os conceitos ou teste o código ao vivo no Playground IDE.
Editor de Códigos Web Online
Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.
Abrir Ferramenta OnlinePlayground Web Online
Escreva seu código HTML, CSS ou JavaScript e veja o resultado renderizado ao vivo no navegador com zero configuração.
⚡ Codificar no Playground IDE