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.

  1. 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.21s
  2. Leia: tudo virou um único JavaScript de 612 kB. A coluna gzip é o que de fato trafega pela rede, comprimido. Liste os arquivos de dist/assets com os tamanhos.

    ls -lh dist/assets
    total 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.js
  3. O aviso sugere import() dinâmico. Você colocou a página de relatórios em lazy no 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.05s
  4. Agora 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 format e o que ela usa internamente
  • Nada: bibliotecas de node_modules sã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 import no 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

  1. Navegador → Servidor: GET index-Ha7m.js. A pessoa abre a página inicial. Só o chunk principal é baixado.
  2. Navegador → Navegador: Clique em Relatórios. O componente lazy precisa aparecer pela primeira vez. O Suspense mostra o fallback.
  3. Navegador → Servidor: GET Relatorios-CkL2.js. O navegador pede o chunk dos relatórios, com a biblioteca de gráficos.
  4. 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.br

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

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

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

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

  4. 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 o memo uma 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 * quantidade para 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 lista

Cada 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.
  • lazy com import() cria chunks separados, e Suspense mostra 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, useCallback e useMemo só 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.

  1. Crie um workflow de CI que rode npm ci, os testes e npm run build a cada push
  2. Anote o tamanho dos chunks do build e a nota do Lighthouse da página principal, em modo celular e sobre npm run preview
  3. Coloque uma rota pesada em lazy com Suspense e um fallback acessível
  4. Gere o build e rode o Lighthouse de novo, nas mesmas condições
  5. Registre no README os números antes e depois, e explique por que a mudança valeu ou não valeu a pena

Referências

Cursos relacionados