Análise do pacote e estratégia de divisão de código
Analise o tamanho do pacote com rollup-plugin-visualizer e defina uma estratégia de divisão de código por rota.
Análise do pacote e estratégia de divisão de código é uma aula grátis de React Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de React Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de React Academy inclui 4 aulas no total.
Por que o tamanho do pacote é importante
Pacotes grandes de JavaScript atrasam o tempo até a interatividade. Cada KB de JS precisa ser baixado, analisado e executado antes que a página se torne interativa — especialmente em redes móveis lentas.
Análise com rollup-plugin-visualizer
Em projetos Vite, utilize o plugin de visualização para gerar um mapa de árvore do seu pacote, mostrando quais módulos ocupam mais espaço.
// vite.config.ts
import { visualizer } from 'rollup-plugin-visualizer';
export default defineConfig({
plugins: [
visualizer({ open: true, gzipSize: true, brotliSize: true })
],
});
// After build, open the generated HTML file to explore the treemapBundle Analyzer do Next.js
Utilize @next/bundle-analyzer para analisar os pacotes do servidor e do cliente no Next.js.
npm install @next/bundle-analyzer
// next.config.js
const withBundleAnalyzer = require('@next/bundle-analyzer')({
enabled: process.env.ANALYZE === 'true',
});
module.exports = withBundleAnalyzer({});
// Run:
// ANALYZE=true npm run buildDivisão de código por rota
A divisão mais impactante é carregar o código de cada rota somente quando o usuário navegar até ela. O React Router com lazy() e o Roteador de Aplicações do Next.js fazem isso automaticamente.
// React Router v6 with lazy loading
import { lazy, Suspense } from 'react';
const Dashboard = lazy(() => import('./pages/Dashboard'));
const Settings = lazy(() => import('./pages/Settings'));
<Routes>
<Route path="/dashboard" element={<Suspense fallback={<Loading />}><Dashboard /></Suspense>} />
<Route path="/settings" element={<Suspense fallback={<Loading />}><Settings /></Suspense>} />
</Routes>Divisão de código por componente
Adie o carregamento de componentes pesados (mapas, gráficos e editores) até que sejam necessários, utilizando lazy().
const MonacoEditor = lazy(() => import('@monaco-editor/react'));
const MapView = lazy(() => import('./MapView'));
function ProductEditor({ showMap }) {
return (
<>
<Suspense fallback={<EditorSkeleton />}><MonacoEditor /></Suspense>
{showMap && <Suspense fallback={<MapSkeleton />}><MapView /></Suspense>}
</>
);
}Importação dinâmica para recursos condicionais
Importe bibliotecas grandes somente quando um recurso for ativado, evitando carregá-las para todos os usuários.
async function exportToPDF() {
const { default: jsPDF } = await import('jspdf'); // ~300KB — loaded on demand
const doc = new jsPDF();
doc.text('Hello', 10, 10);
doc.save('export.pdf');
}Eliminação de código não utilizado
Os empacotadores modernos eliminam exportações não utilizadas (código morto). Garanta que suas dependências ofereçam suporte a ESM (não a CJS) para que essa eliminação funcione e evite importar bibliotecas inteiras quando utilizar apenas uma função.
// Bad — imports entire lodash (~70KB):
import _ from 'lodash';
const result = _.debounce(fn, 300);
// Good — imports only debounce (<2KB):
import debounce from 'lodash/debounce';
// or with tree-shaking-friendly lodash-es:
import { debounce } from 'lodash-es';Pré-carregamento de chunks críticos
Utilize <link rel='modulepreload'> ou comentários especiais do Webpack para pré-carregar o chunk da próxima página enquanto o usuário está na página atual.
// Webpack magic comment — preload on hover:
const Dashboard = lazy(() => import(/* webpackPrefetch: true */ './Dashboard'));
// or preload (higher priority):
const Dashboard = lazy(() => import(/* webpackPreload: true */ './Dashboard'));Análise do impacto de terceiros
Utilize bundlephobia.com ou a extensão Import Cost do VS Code para verificar o tamanho compactado com gzip de qualquer pacote npm antes de instalá-lo.
Definição de um orçamento de tamanho do pacote
Defina um limite de tamanho por rota na configuração do Webpack ou do Vite. A compilação falhará se um chunk exceder o orçamento, detectando regressões acidentais de tamanho na integração contínua.
// vite.config.ts
build: {
rollupOptions: {
output: {
manualChunks: {
'vendor-react': ['react', 'react-dom'],
'vendor-router': ['react-router-dom'],
},
},
},
chunkSizeWarningLimit: 200, // warn at 200KB
},Verificação rápida
Qual é a estratégia de divisão de código mais impactante para SPAs React com muitas páginas?
Recapitulação
Analise os pacotes com rollup-plugin-visualizer ou @next/bundle-analyzer. Utilize divisões por rota e por componente com lazy(). Aplique a eliminação de código não utilizado importando apenas o que utilizar. Defina orçamentos de tamanho na integração contínua e utilize dicas de pré-busca e pré-carregamento para a próxima rota mais provável.
Perguntas Frequentes
A aula “Análise do pacote e estratégia de divisão de código” é grátis?
Sim — o texto completo de “Análise do pacote e estratégia de divisão de código” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de React Academy, atualize para CoddyKit PRO. O curso de React Academy inclui 4 aulas no total.
O que vou aprender em “Análise do pacote e estratégia de divisão de código”?
Analise o tamanho do pacote com rollup-plugin-visualizer e defina uma estratégia de divisão de código por rota. Você pratica React Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar React Academy?
Nenhuma experiência prévia é necessária. React Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Análise do pacote e estratégia de divisão de código”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de React Academy?
Sim. Cada aula de React Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Medindo os Core Web Vitals em aplicativos React
- Análise do pacote e estratégia de divisão de código
- Otimização de imagens e fontes no React
- Reduzindo o INP: otimização de manipuladores de eventos