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 width e height desloca 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: auto o 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.

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

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

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

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

Exemplo de registro antes e depois de otimizar as imagens do catálogo
MedidaAntesDepoisO que mudou
Peso da página4,8 MB1,1 MBFotos em WebP, no tamanho exibido
LCP (celular simulado)5,2 s2,3 sBanner menor e sem loading="lazy"
CLS0,240,02width 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

  1. Atacante → Servidor: Comentário com <img>. No campo de comentário, a pessoa mal-intencionada escreve HTML: <img src=x onerror="...">. O onerror roda JavaScript quando a imagem falha, e ela vai falhar.
  2. Servidor → Servidor: Salva o texto. O servidor guarda o comentário como qualquer outro. Para ele, é só texto.
  3. Navegador → Servidor: GET /comentarios. Outra pessoa abre a página e o navegador dela pede os comentários.
  4. Servidor → Navegador: Lista de comentários. O comentário malicioso chega junto com os outros.
  5. Navegador → Navegador: innerHTML executa. O frontend usa innerHTML para mostrar o texto. O navegador lê aquilo como HTML, cria a imagem e roda o código do atacante.
  6. 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 externo

Proteja 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 o onerror do 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 compatibilidade

npm 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 --force direto e publicar
  • Apagar o package-lock.json e 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, height e loading="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.

  1. Rode o Lighthouse no modo celular e anote LCP, CLS e o peso da página
  2. Faça uma otimização: converta imagens para WebP no tamanho exibido e adicione width e height
  3. Meça de novo nas mesmas condições e registre a tabela de antes e depois no README
  4. Procure no código todo innerHTML, v-html, dangerouslySetInnerHTML ou [innerHTML] que recebe dado externo e troque por texto
  5. Rode npm audit e confira que nenhum segredo está em variáveis VITE_ ou no repositório

Referências

Cursos relacionados