Desempenho e segurança web
Páginas rápidas em celulares modestos e protegidas contra XSS e vazamento de segredos.
Cerca de 15 min · Revisado em
Ao final, você vai conseguir
- Explicar LCP, INP e CLS
- Reduzir peso de imagens e de JavaScript
- Reconhecer e evitar XSS
- Explicar por que segredos não podem ficar no frontend
No seu computador, com wi-fi bom, qualquer site parece rápido. Para muita gente no Brasil, a internet é o pacote de dados pré-pago de um celular intermediário, e cada megabyte que sua página baixa sai do bolso de alguém. Ao mesmo tempo, um único innerHTML descuidado deixa um estranho rodar código no navegador de quem confiou no seu site. Esta aula trata das duas coisas que as pessoas só notam quando dão errado.
Cada megabyte custa
Duas coisas tornam uma página lenta para quem usa: o peso (quantos bytes precisam viajar pela rede) e o trabalho (quanto JavaScript o processador do celular precisa executar). Um celular intermediário pode levar várias vezes mais tempo que um notebook para rodar o mesmo script.
Uma página de 5 MB que a pessoa abre todo dia útil consome quanto do pacote de dados dela num mês?
Cerca de 100 MB, se nada vier do cache. Num pacote pequeno, é uma fatia real, só para ver um site. Reduzir para 1 MB devolve quase 80 MB para ela usar como quiser.
Qual mudança ajuda mais quem abre seu catálogo num celular intermediário com pacote de dados pequeno?
- Trocar a foto de capa de 3 MB por uma versão de 200 KB no tamanho exibido
- Adicionar uma animação de carregamento enquanto a página baixa
- Testar no seu notebook com wi-fi para conferir que está rápido
Três perguntas: LCP, INP e CLS
“Rápido” é vago. O Google propôs três medidas que traduzem a experiência de quem usa em números, chamadas Core Web Vitals (sinais vitais da web). Cada uma responde uma pergunta simples.
Carregamento
LCP: o principal apareceu?
Largest Contentful Paint: quanto tempo até o maior elemento visível (a foto do produto, o título) aparecer.
- Bom: até 2,5 segundos
Resposta
INP: respondeu ao toque?
Interaction to Next Paint: quanto tempo entre tocar ou digitar e a tela mostrar alguma reação.
- Bom: até 200 milissegundos
Estabilidade
CLS: a página pulou?
Cumulative Layout Shift: quanto o conteúdo se mexe sozinho enquanto carrega. Não é tempo, é uma pontuação.
- Bom: até 0,1
Você conhece o CLS de perto: ia tocar em “Cancelar”, um anúncio carregou em cima e você tocou em “Comprar”. A métrica existe porque esse pulo irrita e causa erros reais.
Qual métrica cada problema prejudica?
LCP · INP · CLS
- A foto gigante do banner demora para aparecer
- O servidor leva 3 segundos para devolver o HTML
- O botão “Adicionar ao carrinho” demora para reagir ao toque
- Digitar na busca trava, porque cada letra filtra 5 mil itens
- Um anúncio aparece no topo e empurra o texto para baixo
- Uma imagem sem
widtheheightdesloca o botão quando carrega
Menos peso: imagens e JavaScript
Na maioria das páginas, as imagens são a maior parte dos bytes. Quatro cuidados resolvem quase tudo: o tamanho certo, um formato moderno, carregar só quando for aparecer e reservar o espaço.
Uma imagem de produto bem configurada.
<img
src="tenis-800.webp"
srcset="tenis-400.webp 400w, tenis-800.webp 800w"
sizes="(max-width: 600px) 100vw, 800px"
alt="Tênis de corrida azul, vista lateral"
width="800" height="600"
loading="lazy"
>- Formato moderno: WebP e AVIF costumam ficar bem menores que JPEG e PNG com a mesma qualidade visual. Todos os navegadores atuais suportam WebP.
- Tamanho certo: Você oferece versões de larguras diferentes e diz quanto espaço a imagem ocupa. O celular baixa a de 400 pixels; o monitor grande, a de 800. Ninguém baixa uma foto de 4000 pixels para mostrar em 360.
- Espaço reservado: Com largura e altura, o navegador calcula a proporção e reserva o espaço antes de baixar a imagem. Nada pula quando ela chega: é o remédio para o CLS.
- Carregamento sob demanda: A imagem só é baixada quando está perto de aparecer na tela. Ótimo para fotos no meio da lista; quem não rola a página não paga por elas.
O CSS já tem img { width: 100%; height: auto; }. Por que ainda escrever width e height no HTML da imagem?
- Para o navegador saber a proporção e reservar o espaço antes da imagem chegar, evitando que a página pule
- Para a imagem baixar mais rápido
- Não precisa: com
height: autoo navegador já sabe a altura
Depois das imagens, o vilão é o JavaScript. Cada biblioteca instalada vira bytes para baixar e código para o celular executar. Antes de instalar, pergunte se o navegador já faz aquilo sozinho.
Três jeitos de mandar menos JavaScript
Antes: biblioteca inteira
import moment from 'moment';
import 'moment/locale/pt-br';
// Uma biblioteca de datas grande, só para escrever "14 de outubro"
const texto = moment(pedido.data).locale('pt-br').format('D [de] MMMM');Depois: recurso do navegador
// Intl já vem no navegador: zero bytes a mais
const formatador = new Intl.DateTimeFormat('pt-BR', { day: 'numeric', month: 'long' });
const texto = formatador.format(new Date(pedido.data));Carregar só quando precisar
// O código do mapa só é baixado se a pessoa pedir o mapa
botaoMapa.addEventListener('click', async () => {
const { abrirMapa } = await import('./mapa.js');
abrirMapa();
});Numa lista com 40 produtos, qual imagem deve ficar sem loading="lazy"?
- A foto grande do primeiro produto, visível assim que a página abre
- A foto do último produto, no fim da página
- Nenhuma: lazy em todas é sempre melhor
Meça antes e depois
Otimizar sem medir é chute. Você pode passar um dia economizando 2 KB de JavaScript enquanto uma imagem de 3 MB continua lá. A regra é: meça, mude uma coisa, meça de novo nas mesmas condições.
Rode o Lighthouse
No DevTools, abra a aba Lighthouse, escolha o modo navegação e o dispositivo celular, e gere o relatório. Ele dá notas, mostra LCP e CLS e lista as oportunidades, como imagens grandes demais.
Simule um celular de verdade
Na aba Performance, use as opções de limitação: deixe a CPU mais lenta (por exemplo, 4 vezes) e a rede em 4G lento. Agora você vê a página como boa parte do seu público.
Grave uma interação
Ainda em Performance, grave enquanto clica num botão ou digita na busca. Tarefas longas aparecem marcadas em vermelho: é ali que o INP sofre.
Anote e repita
Rode três vezes e anote o valor do meio, porque cada medição varia. Faça a mudança e meça de novo do mesmo jeito.
| Medida | Antes | Depois | O que mudou |
|---|---|---|---|
| Peso da página | 4,8 MB | 1,1 MB | Fotos em WebP, no tamanho exibido |
| LCP (celular simulado) | 5,2 s | 2,3 s | Banner menor e sem loading="lazy" |
| CLS | 0,24 | 0,02 | width e height em todas as imagens |
Coloque em ordem o ciclo de uma otimização que você consegue defender numa entrevista.
- Medir a página e anotar os números
- Descobrir qual métrica está pior e por quê
- Fazer uma única mudança
- Medir de novo nas mesmas condições
- Registrar o antes e o depois no README ou no pull request
XSS: quando um texto vira ordem
Agora a segurança. O ataque mais comum no frontend se chama XSS (Cross-Site Scripting): alguém consegue colocar código dentro da sua página, e esse código roda no navegador de outras pessoas, com acesso a tudo o que a página acessa.
Como um comentário vira um ataque
- Atacante → Servidor: Comentário com <img>. No campo de comentário, a pessoa mal-intencionada escreve HTML:
<img src=x onerror="...">. Oonerrorroda JavaScript quando a imagem falha, e ela vai falhar. - Servidor → Servidor: Salva o texto. O servidor guarda o comentário como qualquer outro. Para ele, é só texto.
- Navegador → Servidor: GET /comentarios. Outra pessoa abre a página e o navegador dela pede os comentários.
- Servidor → Navegador: Lista de comentários. O comentário malicioso chega junto com os outros.
- Navegador → Navegador: innerHTML executa. O frontend usa
innerHTMLpara mostrar o texto. O navegador lê aquilo como HTML, cria a imagem e roda o código do atacante. - Navegador → Atacante: Envia dados da vítima. O script pode ler o que a página mostra, fazer pedidos em nome da pessoa e mandar informações para fora.
A diferença está em como o texto entra na página
Perigoso
// O texto é interpretado como HTML: tags viram elementos e scripts rodam
item.innerHTML = comentario;Seguro
// O texto é só texto: <img> aparece na tela como os caracteres < i m g >
const item = document.createElement('li');
item.textContent = comentario;
lista.append(item);Nos frameworks
React: <p>{comentario}</p> seguro, escapa o texto
dangerouslySetInnerHTML perigoso, o nome já avisa
Vue: <p>{{ comentario }}</p> seguro
<p v-html="comentario"></p> perigoso
Angular: <p>{{ comentario }}</p> seguro
[innerHTML]="comentario" higienizado, mas evite com dado externoProteja o mural de comentários
Este mural mostra os comentários com innerHTML. Primeiro, ataque: publique <img src=x onerror="console.log(1)"> e veja o console. Depois, reescreva mostrarComentarios usando createElement e textContent, para que qualquer comentário apareça como texto.
<form id="form-comentario">
<label for="campo">Seu comentário</label>
<input id="campo" autocomplete="off">
<button type="submit">Publicar</button>
</form>
<ul id="mural"></ul>body { font-family: system-ui, sans-serif; margin: 16px; }
form { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; }
input { flex: 1; min-width: 160px; padding: 6px; }
#mural { padding: 0; list-style: none; }
#mural li { background: #f3f3f3; border-radius: 8px; padding: 8px 12px; margin-top: 8px; }const comentarios = ['Adorei a aula!', 'Alguém tem dica de CSS Grid?'];
function mostrarComentarios() {
const mural = document.querySelector('#mural');
mural.innerHTML = '';
for (const texto of comentarios) {
mural.innerHTML += '<li>' + texto + '</li>';
}
}
function publicar(texto) {
comentarios.push(texto);
mostrarComentarios();
}
document.querySelector('#form-comentario').addEventListener('submit', (evento) => {
evento.preventDefault();
const campo = document.querySelector('#campo');
if (campo.value.trim()) publicar(campo.value);
campo.value = '';
});
mostrarComentarios();- Um comentário com HTML não cria elementos dentro do mural
- O comentário aparece exatamente como foi digitado, com
<e> - Os comentários continuam aparecendo, um
<li>para cada - Nenhum código injetado foi executado
O servidor da sua equipe já remove <script> dos comentários antes de salvar. Então pode usar innerHTML no frontend?
- Não: há muitos jeitos de rodar código sem
<script>, como oonerrordo exercício. Trate dado externo como texto no frontend também - Sim, sem
<script>nenhum código consegue rodar - Sim, desde que o site use HTTPS
Segredos, dependências e HTTPS
Tudo o que vai para o navegador pode ser lido: o código-fonte, os arquivos do build, cada requisição no painel Network. Minificar só deixa o código feio, não secreto. Lembre da aula de Vite: variáveis com prefixo VITE_ são coladas no build, à vista de qualquer pessoa.
O que pode aparecer no código do frontend e o que nunca pode?
Pode ir para o frontend · Nunca no frontend
- Chave de um serviço de mapas, feita para o navegador e restrita ao seu domínio
- Endereço público da sua API
- Chave publicável de um serviço de pagamento
- Senha do banco de dados
- Chave secreta do serviço de pagamento
- Chave de uma API de IA cobrada por uso
Outro risco são as dependências: os pacotes que você instala também têm falhas de segurança descobertas com o tempo. O npm consulta uma base de falhas conhecidas para você.
Conferindo as dependências
npm audit # lista falhas conhecidas nos pacotes instalados
npm outdated # mostra o que tem versão mais nova
npm audit fix # aplica as correções que não quebram compatibilidadenpm audit aponta uma vulnerabilidade alta num pacote. Qual a atitude mais segura?
- Ler qual pacote é, rodar
npm audit fix, conferir o que mudou no lockfile e rodar os testes antes de juntar - Rodar
npm audit fix --forcedireto e publicar - Apagar o
package-lock.jsone instalar tudo de novo
Fechamento
- Página lenta custa dados e paciência; peso (bytes) e trabalho (JavaScript) são os dois lados do problema.
- LCP mede se o principal apareceu, INP se a tela respondeu ao toque e CLS se a página pulou.
- Imagens no tamanho certo, em WebP ou AVIF, com
width,heighteloading="lazy"fora do topo resolvem a maior parte do peso. - Meça, mude uma coisa e meça de novo nas mesmas condições, registrando antes e depois.
- Dado externo entra na página como texto (
textContent), nunca como HTML; segredos ficam no backend e dependências são atualizadas com testes rodando.
Otimize e proteja o catálogo
Use o projeto de catálogo como laboratório. A entrega não é “ficou rápido”, é um antes e depois com números e uma revisão de onde dados externos entram na página.
- Rode o Lighthouse no modo celular e anote LCP, CLS e o peso da página
- Faça uma otimização: converta imagens para WebP no tamanho exibido e adicione
widtheheight - Meça de novo nas mesmas condições e registre a tabela de antes e depois no README
- Procure no código todo
innerHTML,v-html,dangerouslySetInnerHTMLou[innerHTML]que recebe dado externo e troque por texto - Rode
npm audite confira que nenhum segredo está em variáveisVITE_ou no repositório