0Pricing
React Academy · Lección

Análisis del bundle y estrategia de división de código

Analice el tamaño del bundle con rollup-plugin-visualizer y defina una estrategia de división de código por ruta.

Análisis del bundle y estrategia de división de código es una lección gratuita de React Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de React Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de React Academy incluye 4 lecciones en total.

Por qué importa el tamaño del bundle

Los bundles grandes de JavaScript retrasan el Time To Interactive. Cada KB de JavaScript debe descargarse, analizarse y ejecutarse antes de que la página sea interactiva, especialmente en redes móviles lentas.

Análisis con rollup-plugin-visualizer

En proyectos de Vite, utilice el plugin de visualización para generar un treemap de su bundle que muestre qué módulos ocupan más espacio.

// 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

Next.js Bundle Analyzer

Utilice @next/bundle-analyzer para analizar los bundles del servidor y del cliente en 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

División de código por rutas

La división más eficaz consiste en cargar el código de cada ruta únicamente cuando el usuario navega hasta ella. React Router con lazy() y Next.js App Router lo hacen automáticamente.

// 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>

División de código por componentes

Posponga la carga de componentes pesados, como mapas, gráficos y editores, hasta que sean necesarios mediante 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>}
    </>
  );
}

Importación dinámica para funcionalidades condicionales

Importe las bibliotecas grandes únicamente cuando se active una funcionalidad para evitar cargarlas para todos los usuarios.

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');
}

Tree shaking

Los bundlers modernos eliminan las exportaciones no utilizadas (código muerto). Asegúrese de que sus dependencias sean compatibles con ESM, no solo con CJS, para que funcione el tree shaking, y evite importar bibliotecas completas cuando solo utilice una función.

// 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';

Precarga de chunks críticos

Utilice <link rel='modulepreload'> o los comentarios mágicos de Webpack para precargar el chunk de la siguiente página mientras el usuario permanece en la página actual.

// 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álisis del impacto de terceros

Utilice bundlephobia.com o la extensión Import Cost de VS Code para consultar el tamaño comprimido con gzip de cualquier paquete npm antes de instalarlo.

Configuración de un presupuesto de bundle

Establezca un límite de tamaño por ruta en la configuración de Webpack o Vite. La compilación falla si un chunk supera el presupuesto, lo que permite detectar regresiones de tamaño accidentales en CI.

// vite.config.ts
build: {
  rollupOptions: {
    output: {
      manualChunks: {
        'vendor-react': ['react', 'react-dom'],
        'vendor-router': ['react-router-dom'],
      },
    },
  },
  chunkSizeWarningLimit: 200, // warn at 200KB
},

Comprobación rápida

¿Cuál es la estrategia de división de código más eficaz para SPA de React con muchas páginas?

Repaso

Analice los bundles con rollup-plugin-visualizer o @next/bundle-analyzer. Utilice la división por rutas y por componentes mediante lazy(). Aplique tree shaking importando únicamente lo que utilice. Establezca presupuestos de tamaño en CI y utilice indicadores de prefetch o preload para la siguiente ruta probable.

Preguntas frecuentes

¿La lección «Análisis del bundle y estrategia de división de código» es gratis?

Sí — el texto completo de «Análisis del bundle y estrategia de división de código» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de React Academy, actualiza a CoddyKit PRO. El curso de React Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Análisis del bundle y estrategia de división de código»?

Analice el tamaño del bundle con rollup-plugin-visualizer y defina una estrategia de división de código por ruta. Practicas React Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar React Academy?

No se requiere experiencia previa. React Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Análisis del bundle y estrategia de división de código»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de React Academy?

Sí. Cada lección de React Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Medir las Core Web Vitals en aplicaciones React
  2. Análisis del bundle y estrategia de división de código
  3. Optimización de imágenes y fuentes en React
  4. Reducir INP: optimización de event handlers
← Volver a React Academy