0Pricing
React Academy · Aula

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 treemap

Bundle 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 build

Divisã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

  1. Medindo os Core Web Vitals em aplicativos React
  2. Análise do pacote e estratégia de divisão de código
  3. Otimização de imagens e fontes no React
  4. Reduzindo o INP: otimização de manipuladores de eventos
← Voltar para React Academy