Code Splitting em React: Como Reduzir o Bundle Inicial
O que é code splitting em React
Code splitting em React é a técnica de dividir o bundle JavaScript da aplicação em vários arquivos menores, carregados sob demanda, em vez de um único arquivo enviado ao navegador na primeira visita. O objetivo é reduzir o tempo até a página ficar interativa, entregando primeiro só o código que a tela atual precisa.
Sem code splitting, um projeto React empacota toda a aplicação, cada rota, cada modal, cada biblioteca de terceiros, num único arquivo JavaScript. Suponha uma aplicação com um bundle inicial de 800 KB: o navegador baixa, interpreta e executa esse arquivo inteiro antes de a página responder a qualquer clique, mesmo que o usuário só veja a tela de login. Dividir esse bundle por rota ou por funcionalidade entrega ao navegador só o pedaço necessário para a primeira tela.
Como o lazy() e o import dinâmico dividem o bundle
React.lazy() transforma um import estático de componente em um import dinâmico, que o
bundler separa num arquivo próprio e só busca quando o componente é renderizado pela
primeira vez. A sintaxe troca import Modal from './Modal' por
const Modal = lazy(() => import('./Modal')).
Por baixo, o bundler (Webpack, Turbopack ou o empacotador do Next.js) reconhece a
chamada import() como um ponto de divisão e gera um chunk separado para aquele
módulo. O chunk só entra na rede quando a execução chega até a linha que o referencia,
não antes disso.
React.lazy() sozinho não resolve o problema de interface: enquanto o chunk carrega,
o componente ainda não existe na árvore. É para isso que serve o Suspense, que recebe
um fallback e mostra algo, um spinner ou um skeleton, enquanto a promessa do import
dinâmico não resolve:
const Relatorio = lazy(() => import('./Relatorio'));
function Pagina() {
return (
<Suspense fallback={<Carregando />}>
<Relatorio />
</Suspense>
);
}
Sem o Suspense envolvendo o componente lazy, o React lança um erro em tempo de
renderização, porque não sabe o que mostrar enquanto o chunk ainda não chegou.
Code splitting por rota ou por componente: qual escolher
Dividir por rota separa um chunk para cada página da aplicação, carregado quando o usuário navega até ela. Dividir por componente separa pedaços menores dentro da mesma página, como um modal, uma aba ou um gráfico que só aparece depois de uma interação.
Por rota é o ponto de partida de qualquer projeto, porque o ganho é imediato e o risco
é baixo. Cada página já é uma fronteira natural de navegação, então ninguém fica sem o
código que precisa no momento em que chega. Frameworks como o Next.js já aplicam esse
corte automaticamente por página, sem exigir nenhum lazy() manual.
Por componente exige mais critério, porque nem todo componente compensa o corte. Um modal de confirmação que abre em metade das sessões, um editor de texto rico que só uma função administrativa usa, ou um gráfico pesado numa aba secundária são bons candidatos. Pesam no bundle, mas a maioria das visitas nunca chega a usá-los. Um botão ou um campo de formulário não compensam, porque o custo de mais uma requisição de rede supera o peso mínimo que esses componentes somam ao bundle.
Como implementar code splitting em um projeto React
Aplicar o corte certo depende de medir antes de dividir, não de dividir tudo que existe.
- Rode um analisador de bundle, como o
webpack-bundle-analyzerou o relatório de build do Next.js, para ver quais módulos pesam mais no chunk inicial. - Liste os candidatos que não aparecem na primeira renderização: modais, abas ocultas, rotas administrativas, bibliotecas de terceiros usadas só numa tela específica.
- Troque o import estático desses candidatos por
lazy(() => import(...)), um por vez, para conseguir medir o efeito de cada mudança isoladamente. - Envolva cada componente lazy num
Suspensecom umfallbackque ocupe o mesmo espaço do componente final, para não causar salto de layout quando o chunk chegar. - Rode o analisador de novo e confirme que o chunk inicial encolheu e que nenhum chunk novo ficou maior do que o componente que ele substituiu.
- Repita a cada ciclo de desenvolvimento. Um componente pequeno hoje pode crescer e virar candidato a corte dentro de alguns meses.
Esse processo depende de uma estrutura de projeto que já separe cada funcionalidade em sua própria pasta. Fica mais fácil decidir o que cortar quando as fronteiras entre features já estão claras na arquitetura React do projeto.
Erros comuns ao aplicar code splitting em React
Cortar tudo que é possível, não só o que compensa, é o erro mais comum. Cada
import() dinâmico troca um custo de bundle por um custo de rede: uma nova
requisição, com sua própria latência. Dividir um componente pequeno numa aplicação com
conexão lenta pode deixar a experiência mais lenta do que deixá-lo no bundle
principal.
Esquecer o fallback do Suspense, ou usar um que não ocupa o mesmo espaço do
componente final, é outro erro frequente. Isso causa o mesmo tipo de instabilidade
visual que pesa no tempo de carregamento do site: o
conteúdo pisca ou empurra o resto da tela quando o chunk termina de carregar.
O terceiro erro é dividir em cascata sem perceber: um componente lazy que, dentro de si, importa outro componente lazy, que importa outro. Cada nível adiciona uma viagem de rede sequencial antes de a tela terminar de montar, e o ganho de bundle inicial menor se perde no tempo total até a página responder.
Code splitting em React resolve um problema real de bundle grande, mas só quando aplicado onde o corte paga a própria conta em tempo de rede. Se o seu projeto carrega lento mesmo depois de dividir o bundle, fale com a gente para revisar onde o tempo está indo.