Build e desempenho no React
Entenda o que o build de produção faz, divida o código com lazy e Suspense e otimize só o que a medição apontar.
Cerca de 16 min · Revisado em
Ao final, você vai conseguir
- Explicar bundling, minificação, tree-shaking e code splitting lendo o relatório do vite build
- Carregar uma rota sob demanda com lazy e Suspense
- Usar variáveis VITE_ por ambiente sem expor segredos
- Medir com o React DevTools Profiler e o Lighthouse antes e depois de otimizar
- Aplicar memo, useMemo, useCallback e virtualização apenas quando resolvem um gargalo medido
Seu app funciona no seu notebook, com internet boa. Agora imagine a pessoa que abre o mesmo link num celular simples, com 4G oscilando dentro do ônibus: cada megabyte de JavaScript vira segundos olhando uma tela branca. Nesta aula você vai entender o que acontece quando o projeto React vira uma versão de produção, como dividir o código para carregar só o necessário e como provar, com números, que uma otimização valeu a pena.
Do seu código ao que o navegador baixa
Na aula de ferramentas você rodou npm run build e viu nascer a pasta dist/. Agora vamos abrir essa caixa. O Vite pega dezenas de arquivos .jsx, mais as bibliotecas de node_modules, e entrega poucos arquivos pequenos, prontos para qualquer navegador.
- Bundling (empacotamento)
- Juntar os muitos arquivos e
imports em poucos arquivos, chamados chunks (pedaços). Menos arquivos, menos pedidos ao servidor. - Minificação
- Apagar espaços, comentários e encurtar nomes de variáveis. O código continua funcionando, só fica ilegível para humanos e bem menor.
- Tree-shaking
- Literalmente “sacudir a árvore”: o que foi exportado mas nunca importado cai fora. Se você usa uma função de uma biblioteca com cem, só ela entra.
- Hash no nome
- O build nomeia arquivos como
index-D3fK9aLm.js. O código mudou, o nome muda; assim o navegador nunca usa uma versão velha guardada em cache.
O mesmo componente antes e depois da minificação
Você escreve
// Mostra o preço formatado em reais
function Preco({ valor }) {
const formatado = valor.toLocaleString('pt-BR', {
style: 'currency',
currency: 'BRL',
});
return <span className="preco">{formatado}</span>;
}Vai para dist/
function n({valor:e}){const r=e.toLocaleString("pt-BR",{style:"currency",currency:"BRL"});return t.jsx("span",{className:"preco",children:r})}Lendo o relatório do build
Este é o catálogo de uma loja, com uma página de relatórios que usa uma biblioteca de gráficos. Gere a versão de produção e leia o que o Vite conta.
Gere a versão de produção do projeto.
npm run build> catalogo@0.0.0 build > tsc -b && vite build vite v6.0.7 building for production... ✓ 412 modules transformed. dist/index.html 0.46 kB │ gzip: 0.30 kB dist/assets/index-Bx81kd2Q.css 4.12 kB │ gzip: 1.38 kB dist/assets/index-D3fK9aLm.js 612.48 kB │ gzip: 189.02 kB (!) Some chunks are larger than 500 kB after minification. Consider: - Using dynamic import() to code-split the application - Use build.rollupOptions.output.manualChunks to improve chunking - Adjust chunk size limit for this warning via build.chunkSizeWarningLimit. ✓ built in 3.21sLeia: tudo virou um único JavaScript de 612 kB. A coluna
gzipé o que de fato trafega pela rede, comprimido. Liste os arquivos dedist/assetscom os tamanhos.ls -lh dist/assetstotal 624K -rw-r--r-- 1 voce voce 4.1K out 14 15:02 index-Bx81kd2Q.css -rw-r--r-- 1 voce voce 599K out 14 15:02 index-D3fK9aLm.jsO aviso sugere
import()dinâmico. Você colocou a página de relatórios emlazyno editor (vamos ver como na próxima seção). Gere o build de novo e compare.npm run build> catalogo@0.0.0 build > tsc -b && vite build vite v6.0.7 building for production... ✓ 413 modules transformed. dist/index.html 0.46 kB │ gzip: 0.30 kB dist/assets/index-Bx81kd2Q.css 4.12 kB │ gzip: 1.38 kB dist/assets/Relatorios-CkL2p9Qe.js 318.70 kB │ gzip: 97.15 kB dist/assets/index-Ha7mQ2xT.js 294.03 kB │ gzip: 92.40 kB ✓ built in 3.05sAgora a página inicial baixa metade do JavaScript, e os gráficos só vêm quando alguém abre os relatórios. Sirva a pasta
dist/localmente para testar a versão de produção.npm run preview> catalogo@0.0.0 preview > vite preview ➜ Local: http://localhost:4173/ ➜ Network: use --host to expose
Você importou só a função format de uma biblioteca de datas que tem mais de 200 funções. Com tree-shaking, o que vai para o build?
- A biblioteca inteira, porque ela está no
package.json - A função
formate o que ela usa internamente - Nada: bibliotecas de
node_modulessão baixadas pelo navegador direto do npm
Dividir para carregar só o necessário
Mesmo minificado, um app grande pode ter muito JavaScript. Mas quem abre a página inicial não precisa do código dos relatórios, do painel de administração ou do checkout. Code splitting (divisão de código) é separar essas partes em chunks que só são baixados quando alguém precisa deles.
lazy pede o componente só quando ele vai aparecer; Suspense mostra algo enquanto isso
import { lazy, Suspense } from 'react';
const Relatorios = lazy(() => import('./pages/Relatorios'));
function App() {
return (
<Suspense fallback={<p>Carregando relatório...</p>}>
<Routes>
<Route path="/" element={<Inicio />} />
<Route path="/relatorios" element={<Relatorios />} />
</Routes>
</Suspense>
);
}- import() dinâmico
- Diferente do
importno topo do arquivo,import('./arquivo')é uma função que devolve uma Promise. O Vite vê isso e cria um chunk separado. - lazy
- Transforma esse
import()num componente. Na primeira vez que ele precisa aparecer, o React pede o arquivo e espera. - Suspense
- Uma moldura que mostra o
fallback(um aviso ou esqueleto) enquanto algum componente lazy dentro dela ainda está chegando.
A página de relatórios chegando sob demanda
- Navegador → Servidor: GET index-Ha7m.js. A pessoa abre a página inicial. Só o chunk principal é baixado.
- Navegador → Navegador: Clique em Relatórios. O componente lazy precisa aparecer pela primeira vez. O Suspense mostra o
fallback. - Navegador → Servidor: GET Relatorios-CkL2.js. O navegador pede o chunk dos relatórios, com a biblioteca de gráficos.
- Servidor → Navegador: 200 OK. O arquivo chega, o React troca o aviso pelo componente. Na próxima visita a essa página, ele já está carregado.
Relatório sob demanda
Aqui o import() é simulado com uma espera de 0,8 segundo. Clique em Abrir relatório e veja o erro no console: um componente lazy precisa de um Suspense acima dele. Envolva o <Relatorio /> num Suspense com um fallback que diga “Carregando relatório...”.
<div id="root"></div>body { font-family: system-ui, sans-serif; margin: 16px; }
button { padding: 6px 12px; cursor: pointer; }
.relatorio { margin-top: 12px; padding: 12px; background: #e0f2fe; border-radius: 8px; }const { useState, lazy, Suspense } = React;
function RelatorioDeVendas() {
return (
<section id="relatorio" className="relatorio">
<h2>Vendas da semana</h2>
<p>Pão de queijo: 312 · Café coado: 198 · Bolo de fubá: 87</p>
</section>
);
}
// simula import('./Relatorio'): o arquivo leva 0,8 s para chegar
const Relatorio = lazy(
() => new Promise((resolve) => setTimeout(() => resolve({ default: RelatorioDeVendas }), 800)),
);
function App() {
const [aberto, setAberto] = useState(false);
return (
<main>
<h1>Painel da padaria</h1>
<button onClick={() => setAberto(true)}>Abrir relatório</button>
{aberto && <Relatorio />}
</main>
);
}
ReactDOM.createRoot(document.getElementById('root')).render(<App />);- Logo após o clique aparece “Carregando relatório...”
- Depois de carregar, o relatório de vendas aparece
Qual destas partes de um app de delivery é a melhor candidata a lazy?
- O botão de busca que aparece no topo de todas as telas
- A página de histórico de pedidos, com gráficos de gastos do mês
- Cada pequeno componente do app, como botões e ícones
Variáveis de ambiente e a fronteira com o servidor
O mesmo código roda em lugares diferentes: no seu computador, apontando para uma API de teste, e em produção, apontando para a API real. Variáveis de ambiente guardam essas diferenças fora do código. Você já viu na aula de ferramentas que o Vite só entrega ao app as que começam com VITE_.
Um valor por ambiente, lido do mesmo jeito no código
.env.development
VITE_API_URL=http://localhost:3000.env.production
VITE_API_URL=https://api.padaria.com.brapi.js
const base = import.meta.env.VITE_API_URL;
if (import.meta.env.DEV) {
console.log('Modo desenvolvimento, API em', base);
}
export function buscarProdutos() {
return fetch(`${base}/produtos`).then((r) => r.json());
}No npm run dev, vale o .env.development; no npm run build, o .env.production. O Vite escreve o valor dentro do JavaScript gerado. Por isso, mudar o .env depois do build não muda nada: é preciso gerar o build de novo.
Este valor pode ir para uma variável VITE_ ou precisa ficar no servidor?
Pode ser VITE_ (público) · Só no servidor (segredo)
- Endereço da API pública da loja
- ID de medição do Google Analytics
- Número da versão do app
- Chave secreta do gateway de pagamento
- Senha do banco de dados
- Token pessoal do GitHub para criar issues
No .env está API_URL=https://api.loja.com.br, mas import.meta.env.API_URL aparece como undefined no app. Por quê?
- Falta o prefixo
VITE_, então o Vite não expõe a variável ao código - Variáveis de ambiente só funcionam no backend, nunca no React
- O endereço precisa estar entre aspas no
.env
Meça antes de otimizar
Para o carregamento, você já conhece o Lighthouse e as métricas da aula de desempenho e segurança. Para lentidão depois que a página abriu, como digitar e a tela engasgar, a ferramenta é o Profiler do React DevTools, uma extensão do navegador.
Instale o React DevTools
Procure “React Developer Tools” na loja de extensões do Chrome, Edge ou Firefox. No DevTools (
F12) aparecem duas abas novas: Components e Profiler.Ligue o destaque de renderizações
Na engrenagem do Profiler, marque “Highlight updates when components render”. Cada componente que renderiza pisca com uma borda colorida.
Grave a interação lenta
Na aba Profiler, clique no círculo para gravar, faça a ação que parece lenta (digitar, filtrar, abrir um menu) e clique de novo para parar.
Leia o gráfico
Cada barra é um componente. Cinza quer dizer que não renderizou; amarelo e laranja, que demorou mais. Clique numa barra para ver quanto tempo levou e por que renderizou.
Coloque em ordem um ciclo honesto de otimização.
- Reproduzir a lentidão e medir, anotando o número
- Usar o Profiler ou o Lighthouse para achar a causa
- Mudar uma coisa só, focada na causa
- Medir de novo nas mesmas condições
- Manter a mudança se o número melhorou, desfazer se não
memo, useMemo e useCallback: quando importam
Quando o estado de um componente muda, o React renderiza esse componente e todos os filhos dele, mesmo os que receberam as mesmas props. Quase sempre isso é rápido e está tudo bem. Mas, quando um filho é caro de desenhar, vale pedir ao React que pule o que não mudou.
- memo
- Envolve um componente:
const Item = memo(function Item(props) {...}). Se as props forem iguais às da última vez, o React reaproveita o resultado e não renderiza. - useCallback
- Guarda a mesma função entre renderizações:
useCallback(fn, [dependencias]). Sem ele, cada renderização cria uma função nova, e para omemouma função nova é uma prop diferente. - useMemo
- Guarda o resultado de um cálculo:
useMemo(() => filtrar(lista, busca), [lista, busca]). Só recalcula quando uma dependência muda.
Contando renderizações
Digite na anotação e veja no console: cada letra renderiza os cinco itens de novo, embora nada neles tenha mudado. Envolva Item em memo. Repare que ainda renderiza: a função favoritar nasce nova a cada vez. Estabilize-a com useCallback.
<div id="root"></div>body { font-family: system-ui, sans-serif; margin: 16px; }
input { padding: 6px; width: 220px; }
li { margin: 4px 0; }
button { margin-left: 8px; cursor: pointer; }const { useState, memo, useCallback } = React;
window.renderizacoes = 0;
const produtos = ['Arroz', 'Feijão', 'Farinha', 'Café', 'Açúcar'];
function Item({ nome, onFavoritar }) {
window.renderizacoes++;
console.log('renderizou', nome);
return (
<li>
{nome}
<button onClick={() => onFavoritar(nome)}>Favoritar {nome}</button>
</li>
);
}
function Lista() {
const [anotacao, setAnotacao] = useState('');
const [favorito, setFavorito] = useState('nenhum');
function favoritar(nome) {
setFavorito(nome);
}
return (
<div>
<input
aria-label="Anotação"
placeholder="Digite uma anotação"
value={anotacao}
onChange={(e) => setAnotacao(e.target.value)}
/>
<p>Favorito: <strong id="favorito">{favorito}</strong></p>
<ul>
{produtos.map((p) => (
<Item key={p} nome={p} onFavoritar={favoritar} />
))}
</ul>
</div>
);
}
ReactDOM.createRoot(document.getElementById('root')).render(<Lista />);- Digitar na anotação não renderiza os itens de novo
- Favoritar Café continua mostrando “Café” como favorito
Você eliminou dez renderizações por letra digitada. Esse app ficou perceptivelmente mais rápido?
Provavelmente não. Cinco itens simples renderizam em frações de milissegundo; ninguém nota a diferença. O exercício mostra o mecanismo. Na vida real, você só aplica memo quando o Profiler mostra um componente caro renderizando à toa, como uma tabela com centenas de linhas ou um gráfico.
Em qual situação useMemo provavelmente faz diferença de verdade?
- Calcular
preco * quantidadepara mostrar o subtotal - Filtrar e ordenar 20 mil linhas de pedidos a cada tecla digitada em outro campo
- Em todo componente, para garantir que o app nunca fique lento
Listas gigantes: renderize só o que aparece
Uma tabela com 10 mil pedidos cria 10 mil linhas no DOM, mesmo que a tela mostre só 15. O navegador gasta memória e tempo desenhando o que ninguém vê. memo não resolve isso: o problema é a quantidade, não as renderizações repetidas.
A ideia por trás da virtualização, em poucas linhas
const alturaLinha = 40; // cada linha tem 40px
const alturaJanela = 600; // a área visível tem 600px
const primeira = Math.floor(scrollTop / alturaLinha);
const quantas = Math.ceil(alturaJanela / alturaLinha) + 1;
const visiveis = pedidos.slice(primeira, primeira + quantas);
// renderiza só "visiveis" (16 linhas), num contêiner com a altura total da listaCada linha tem 50px e a pessoa rolou 1000px. Complete o cálculo da primeira linha visível e do pedaço da lista que vai para a tela.
const primeira = Math.floor(1000 / 50); // ____
const visiveis = pedidos.____(primeira, primeira + 13);Uma tela de extrato com 8 mil transações do Pix trava ao abrir. O Profiler mostra que o tempo vai todo para criar as linhas na primeira renderização. Qual o melhor primeiro passo?
- Envolver cada linha em
memo - Mostrar só as linhas visíveis, com paginação ou virtualização
- Trocar todas as funções por
useCallback
Fechamento
- O build junta os arquivos em chunks, minifica, remove o que não é usado (tree-shaking) e coloca hash nos nomes para o cache não servir versões velhas.
lazycomimport()cria chunks separados, eSuspensemostra um aviso enquanto eles chegam; dividir por rota é o ponto de partida.- Variáveis
VITE_são gravadas no JavaScript e ficam públicas: segredos ficam no servidor. - Meça antes e depois com o Profiler e o Lighthouse, em versão de produção, mudando uma coisa por vez.
memo,useCallbackeuseMemosó valem quando a medição mostra renderização ou cálculo caro; listas enormes pedem paginação ou virtualização.
Prove uma melhoria com números
Publique a versão de produção do seu app React com um build reproduzível e documente uma melhoria de desempenho com evidência antes e depois.
- Crie um workflow de CI que rode
npm ci, os testes enpm run builda cada push - Anote o tamanho dos chunks do build e a nota do Lighthouse da página principal, em modo celular e sobre
npm run preview - Coloque uma rota pesada em
lazycomSuspensee um fallback acessível - Gere o build e rode o Lighthouse de novo, nas mesmas condições
- Registre no README os números antes e depois, e explique por que a mudança valeu ou não valeu a pena