Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura

Code splitting i tree shaking

9 min czytania ·
W tej lekcji11

W świecie nowoczesnego web developmentu, gdzie aplikacje stają się coraz bardziej złożone, zarządzanie wielkością bundli JavaScript jest kluczowe dla wydajności. Dwie fundamentalne techniki optymalizacji - code splitting i tree shaking - pozwalają nam drastycznie zmniejszyć rozmiar kodu trafiającego do użytkowników.

Czym jest code splitting?

Code splitting to technika dzielenia kodu na mniejsze fragmenty (chunki), które mogą być ładowane na żądanie (lazy loading) lub równolegle. Zamiast wysyłać cały kod aplikacji w jednym wielkim bundlu, możemy podzielić go na logiczne części i ładować tylko to, czego aktualnie potrzebujemy.

Problemy rozwiązywane przez code splitting

// Problem: Jeden wielki bundle
// main.bundle.js (2.5MB)
// - Kod strony głównej (200KB)
// - Kod panelu administracyjnego (800KB)
// - Kod sklepu internetowego (1.5MB)
// Użytkownik widząc tylko stronę główną pobiera niepotrzebnie 2.3MB kodu!

// Rozwiązanie: Code splitting
// main.bundle.js (200KB) - tylko kod strony głównej
// admin.chunk.js (800KB) - ładowany tylko gdy potrzebny
// shop.chunk.js (1.5MB) - ładowany tylko gdy potrzebny

Rodzaje code splitting

1. Code splitting według tras

Najprostszy i najczęściej używany rodzaj - dzielenie kodu według tras aplikacji:

// React Router z lazy loading
import { lazy, Suspense } from 'react';
import { Routes, Route } from 'react-router';

// Każdy komponent to osobny chunk
const HomePage = lazy(() => import('./pages/HomePage'));
const ProductPage = lazy(() => import('./pages/ProductPage'));
const AdminPanel = lazy(() => import('./pages/AdminPanel'));

function App() {
  return (
    <Suspense fallback={<div>Ładowanie...</div>}>
      <Routes>
        <Route path="/" element={<HomePage />} />
        <Route path="/product/:id" element={<ProductPage />} />
        <Route path="/admin" element={<AdminPanel />} />
      </Routes>
    </Suspense>
  );
}

2. Code splitting na poziomie komponentów

Dzielenie kodu na poziomie komponentów:

// Lazy loading pojedynczych komponentów
const ExpensiveChart = lazy(() => import('./components/ExpensiveChart'));
const HeavyDataTable = lazy(() => import('./components/HeavyDataTable'));

function Dashboard({ showChart, showTable }) {
  return (
    <div>
      <h1>Panel główny</h1>

      {showChart && (
        <Suspense fallback={<div>Ładowanie wykresu...</div>}>
          <ExpensiveChart />
        </Suspense>
      )}

      {showTable && (
        <Suspense fallback={<div>Ładowanie tabeli...</div>}>
          <HeavyDataTable />
        </Suspense>
      )}
    </div>
  );
}

3. Dynamiczne importy

Importowanie kodu w odpowiedzi na akcje użytkownika:

// Ładowanie biblioteki tylko gdy potrzebna
async function showAdvancedEditor() {
  // CodeMirror jest ładowany tylko gdy użytkownik kliknie przycisk
  const { EditorView, basicSetup } = await import('codemirror');
  const { javascript } = await import('@codemirror/lang-javascript');

  const editor = new EditorView({
    extensions: [basicSetup, javascript()],
    parent: document.getElementById('editor-container')
  });
}

// Event listener na przycisku
document.getElementById('show-editor').addEventListener('click', showAdvancedEditor);

4. Wydzielanie bibliotek zewnętrznych (vendor)

Separowanie bibliotek zewnętrznych od kodu aplikacji:

// webpack.config.js
module.exports = {
  optimization: {
    splitChunks: {
      chunks: 'all',
      cacheGroups: {
        // Biblioteki zewnętrzne w osobnym chunk
        vendor: {
          test: /[\\/]node_modules[\\/]/,
          name: 'vendors',
          chunks: 'all',
        },
        // Wspólny kod aplikacji
        common: {
          name: 'common',
          minChunks: 2,
          chunks: 'all',
          enforce: true
        }
      }
    }
  }
};

Czym jest tree shaking?

Tree shaking to proces usuwania "martwego kodu" (dead code) - czyli kodu, który nie jest używany w aplikacji. Nazwa pochodzi od metafory "potrząsania drzewem", gdzie opadają tylko niepotrzebne liście (nieużywany kod).

Jak działa tree shaking?

// utils.js - eksportujemy wiele funkcji
export function formatDate(date) {
  return date.toLocaleDateString();
}

export function formatTime(date) {
  return date.toLocaleTimeString();
}

export function formatCurrency(amount) {
  return new Intl.NumberFormat('pl-PL', {
    style: 'currency',
    currency: 'PLN'
  }).format(amount);
}

export function validateEmail(email) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

// main.js - importujemy tylko to czego potrzebujemy
import { formatDate, formatCurrency } from './utils.js';

// Tree shaking usunie formatTime i validateEmail z finalnego bundle
console.log(formatDate(new Date()));
console.log(formatCurrency(100));

Warunki konieczne dla tree shaking

  1. ES Modules (ESM) - tree shaking działa tylko z ES6 modules:
// Działa z tree shaking (ES modules)
import { specificFunction } from './module.js';

// Nie działa z tree shaking (CommonJS)
const { specificFunction } = require('./module.js');
  1. Static imports - importy muszą być statyczne:
// Static import - tree shaking działa
import { debounce } from 'lodash-es';

// Dynamic import - tree shaking nie działa
const moduleName = 'lodash-es';
import(moduleName).then(module => {
  const { debounce } = module;
});
  1. Named exports - preferujemy named exports nad default exports:
// Named exports - lepsze dla tree shaking
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

// Default export z obiektem - gorsze dla tree shaking
export default {
  add: (a, b) => a + b,
  subtract: (a, b) => a - b
};

Praktyczne przykłady optymalizacji

Optymalizacja bibliotek CSS

// Importowanie całej biblioteki Bootstrap
import 'bootstrap/dist/css/bootstrap.css';

// Importowanie tylko potrzebnych modułów (własny plik SCSS)
import './bootstrap-custom.scss';
// bootstrap-custom.scss (Bootstrap 5): pliki częściowe Sass dołączasz z SCSS, nie z JavaScriptu
@import 'bootstrap/scss/functions';
@import 'bootstrap/scss/variables';
@import 'bootstrap/scss/variables-dark';
@import 'bootstrap/scss/maps';
@import 'bootstrap/scss/mixins';
@import 'bootstrap/scss/utilities';

// Tylko klasy display (d-*), margin (m-*) i padding (p-*)
$utilities: map-get-multiple($utilities, ('display', 'margin', 'padding'));

@import 'bootstrap/scss/utilities/api';

Optymalizacja bibliotek JavaScript

// Importowanie całej biblioteki Lodash (>70KB)
import _ from 'lodash';
const result = _.debounce(handleSearch, 300);

// Importowanie tylko potrzebnej funkcji z lodash-es
import { debounce } from 'lodash-es';
const result = debounce(handleSearch, 300);

// Lub jeszcze lepiej - pojedyncza funkcja
import debounce from 'lodash-es/debounce';
const result = debounce(handleSearch, 300);

Tree shaking w React

// Import przestrzeni nazw - przy statycznym dostępie (MUI.Button) bundler i tak usunie nieużywane komponenty
import * as MUI from '@mui/material';

// Importowanie tylko potrzebnych komponentów
import { Button, TextField, Card } from '@mui/material';

// Lub indywidualne importy
import Button from '@mui/material/Button';
import TextField from '@mui/material/TextField';
import Card from '@mui/material/Card';

Konfiguracja bundlerów

Webpack

// webpack.config.js
module.exports = {
  mode: 'production', // Włącza tree shaking automatycznie
  optimization: {
    usedExports: true, // Oznacza używane eksporty
    sideEffects: true, // Respektuje pole "sideEffects" z package.json (domyślne w trybie production)
    splitChunks: {
      chunks: 'all',
      cacheGroups: {
        vendor: {
          test: /[\\/]node_modules[\\/]/,
          name: 'vendors',
          chunks: 'all',
        }
      }
    }
  }
};

Vite

// vite.config.js - Vite 8+ (Rolldown); w Vite 7 i starszych: build.rollupOptions.output.manualChunks
import { defineConfig } from 'vite';

export default defineConfig({
  build: {
    rolldownOptions: {
      output: {
        codeSplitting: {
          groups: [
            { name: 'vendor', test: /[\\/]node_modules[\\/](react|react-dom)[\\/]/ },
            { name: 'utils', test: /[\\/]node_modules[\\/](lodash-es|date-fns)[\\/]/ }
          ]
        }
      }
    }
  }
});

Rollup

// rollup.config.js
export default {
  input: 'src/main.js',
  output: {
    dir: 'dist',
    format: 'es',
    manualChunks: (id) => {
      if (id.includes('node_modules')) {
        return 'vendor';
      }
    }
  },
  external: ['react', 'react-dom']
};

Zaawansowane techniki

Preloading i prefetching

// Preload - wysoki priorytet, potrzebne od razu
const AdminPanel = lazy(() =>
  import(/* webpackPreload: true */ './AdminPanel')
);

// Prefetch - niski priorytet, prawdopodobnie potrzebne później
const UserProfile = lazy(() =>
  import(/* webpackPrefetch: true */ './UserProfile')
);

Analiza bundla

Plugin webpack-bundle-analyzer zapisuje przy każdym buildzie raport HTML z mapą bundla: każdy moduł jest prostokątem o polu proporcjonalnym do rozmiaru, więc od razu widać, co zajmuje najwięcej miejsca:

// Analiza bundla za pomocą webpack-bundle-analyzer
const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;

module.exports = {
  plugins: [
    new BundleAnalyzerPlugin({
      analyzerMode: 'static',
      openAnalyzer: false,
      generateStatsFile: true
    })
  ]
};

Własne strategie ładowania

Możesz też dobierać wersję komponentu do jakości połączenia, którą podaje Network Information API (navigator.connection). Działa ono tylko w przeglądarkach opartych na Chromium, więc w pozostałych kod wybierze lżejszą wersję:

// Strategia ładowania na podstawie połączenia internetowego
async function loadComponentBasedOnConnection() {
  const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;

  if (connection && connection.effectiveType === '4g') {
    // Szybkie połączenie - ładujemy pełną wersję
    return import('./components/FullFeaturedComponent');
  } else {
    // Wolne połączenie - ładujemy uproszczoną wersję
    return import('./components/LightweightComponent');
  }
}

Efekty uboczne (side effects) i package.json

Pole sideEffects w package.json biblioteki mówi bundlerowi, czy jej moduły mają efekty uboczne. Wartość false oznacza, że nie ma ich żaden plik, więc moduł, z którego nic nie importujesz, bundler może całkowicie pominąć:

{
  "name": "my-library",
  "version": "1.0.0",
  "sideEffects": false,
  "main": "dist/index.js",
  "module": "dist/index.esm.js"
}

Pliki z efektami ubocznymi, których bundler nie może pominąć, wymieniasz w tablicy:

{
  "sideEffects": [
    "src/polyfills.js",
    "src/global-styles.css",
    "**/*.css"
  ]
}

Praktyczne wskazówki

1. Monitorowanie rozmiaru bundla

Zanim dodasz bibliotekę do projektu, sprawdź, ile waży po minifikacji i po kompresji gzip:

# Używanie bundlephobia do sprawdzania rozmiaru bibliotek
npm install -g bundle-phobia-cli
bundle-phobia lodash
bundle-phobia lodash-es

2. Webpack Bundle Analyzer

npm install --save-dev webpack-bundle-analyzer
npx webpack --profile --json=stats.json
npx webpack-bundle-analyzer stats.json

3. Lighthouse CI dla monitorowania

# .github/workflows/lighthouse.yml
- name: Lighthouse CI
  run: |
    npm install -g @lhci/cli
    lhci autorun

Przykład pełnej optymalizacji

// Przed optymalizacją
import React from 'react';
import * as MUI from '@mui/material';
import _ from 'lodash';
import moment from 'moment';
import './styles.css';

function App() {
  const [users, setUsers] = React.useState([]);

  const debouncedSearch = _.debounce((query) => {
    // Wyszukiwanie użytkowników
  }, 300);

  return (
    <MUI.Container>
      <MUI.TextField onChange={(e) => debouncedSearch(e.target.value)} />
      {users.map(user => (
        <MUI.Card key={user.id}>
          <MUI.Typography>
            {user.name} - {moment(user.createdAt).format('DD/MM/YYYY')}
          </MUI.Typography>
        </MUI.Card>
      ))}
    </MUI.Container>
  );
}
// Po optymalizacji
import React, { useState, lazy, Suspense } from 'react';
import { Container, TextField } from '@mui/material';
import { debounce } from 'lodash-es';
import { format } from 'date-fns';
import { pl } from 'date-fns/locale';

// Lazy loading dla rzadko używanych komponentów
const UserCard = lazy(() => import('./components/UserCard'));

function App() {
  const [users, setUsers] = useState([]);

  const debouncedSearch = debounce((query) => {
    // Wyszukiwanie użytkowników
  }, 300);

  return (
    <Container>
      <TextField onChange={(e) => debouncedSearch(e.target.value)} />
      <Suspense fallback={<div>Ładowanie...</div>}>
        {users.map(user => (
          <UserCard
            key={user.id}
            name={user.name}
            date={format(new Date(user.createdAt), 'dd/MM/yyyy', { locale: pl })}
          />
        ))}
      </Suspense>
    </Container>
  );
}

Korzyści i rezultaty

Oszczędności w rozmiarze bundla

  • Lodash: 70KB → 2KB (pojedyncza funkcja)
  • Moment.js: 230KB → 11KB (date-fns)
  • Material-UI: 1.2MB → 200KB (tylko używane komponenty)
  • Bootstrap: 150KB → 30KB (tylko potrzebne moduły)

Wpływ na wydajność

// Metryki wydajności
const performanceMetrics = {
  beforeOptimization: {
    bundleSize: '2.5MB',
    firstContentfulPaint: '3.2s',
    largestContentfulPaint: '4.8s',
    timeToInteractive: '5.2s'
  },
  afterOptimization: {
    bundleSize: '450KB',
    firstContentfulPaint: '1.1s',
    largestContentfulPaint: '1.8s',
    timeToInteractive: '2.1s'
  }
};

Podsumowanie

Code splitting i tree shaking to fundamentalne techniki optymalizacji nowoczesnych aplikacji web. Pozwalają one:

  1. Zmniejszyć początkowy rozmiar bundla - użytkownicy pobierają tylko kod potrzebny do pierwszego renderu
  2. Przyspieszyć czas ładowania - mniejsze pliki = szybsze pobieranie
  3. Poprawić User Experience - aplikacja działa szybciej i płynniej
  4. Zaoszczędzić transfer danych - szczególnie ważne na mobilnych urządzeniach
  5. Umożliwić lepsze cachowanie - biblioteki zewnętrzne (vendor) rzadko się zmieniają

Kluczem do sukcesu jest systematyczne podejście: regularny audyt bundla, monitoring rozmiaru bibliotek i świadome decyzje o tym, jakie zależności dodajemy do projektu.

W edytorze poniżej policzysz na przykładowych danych, ile kilobajtów zwiedzający oszczędza na starcie dzięki code splittingowi i tree shakingowi.

Kod do tej lekcji: index.js
// Code splitting i tree shaking w liczbach: symulacja bundla Parku Jurajskiego
// Zmieniaj dane poniżej i obserwuj, ile kilobajtów zwiedzający pobiera na starcie.

// static = zwykły import (moduł trafia do pakietu startowego)
// dynamic = import('./plik.js') (bundler wydziela osobny chunk pobierany na żądanie)
const modules = [
  { file: 'app.js', kb: 45, load: 'static' },
  { file: 'park-map.js', kb: 120, load: 'static' },
  { file: 'admin-panel.js', kb: 310, load: 'dynamic' },
  { file: 'genetics-charts.js', kb: 180, load: 'dynamic' },
];

const totalKb = (list) => list.reduce((sum, m) => sum + m.kb, 0);
const initial = modules.filter((m) => m.load === 'static');
const chunks = modules.filter((m) => m.load === 'dynamic');

console.log('Bez code splittingu na starcie:', totalKb(modules), 'kB');
console.log('Z code splittingiem na starcie:', totalKb(initial), 'kB');
console.log('Chunki pobierane na żądanie:', chunks.map((m) => m.file + ' (' + m.kb + ' kB)').join(', '));

// Tree shaking: do bundla trafiają tylko eksporty, które importujesz (rozmiary w kB)
const parkUtils = { formatDate: 2, debounce: 3, deepClone: 6, chartEngine: 95 };
const imported = ['formatDate', 'debounce'];
const libraryKb = Object.values(parkUtils).reduce((sum, kb) => sum + kb, 0);
const shakenKb = imported.reduce((sum, name) => sum + parkUtils[name], 0);
console.log('Cała biblioteka:', libraryKb, 'kB');
console.log('Po tree shakingu:', shakenKb, 'kB');

// Spróbuj: zmień load modułu park-map.js na 'dynamic' albo dopisz 'chartEngine' do imported.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Czym charakteryzuje się pure function (czysta funkcja)?

  2. 2. Co to jest immutable state (niemutowalny stan)?

To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj kroki implementacji niemutowalnego stanu:

  • Edytor kodu

    W pliku index.html jest kontener #park-app i skrypt z klasą ParkInterface, która buduje panel sterowania parku z danych parkData (wygląd paneli jest w style.css). Uzupełnij luki: ___BLANK1___ to metoda tablicy, która z każdego dinozaura robi napis z elementem <li>, ___BLANK2___ to metoda tablicy, która skleja te napisy w jeden (bez przecinków między nimi), a ___BLANK3___ to właściwość elementu, przez którą render() wstawia gotowy HTML do kontenera. Po uruchomieniu w #park-app mają być trzy panele .panel z nagłówkami h2, a w pierwszym lista wszystkich dinozaurów; render() ma działać też dla innego kontenera i innych danych.

  • Klikanie w kolejności

    Ułóż elementy wzorca Factory:

  • Edytor kodu

    W pliku index.js jest klasa TimeSimulation. Uzupełnij luki: ___BLANK1___ to liczba godzin w dobie, po której licznik godzin wraca do 0 (tick() po 23:00 daje 0:00 i kolejny dzień), ___BLANK2___ to operator logiczny w isNight(), bo noc to godziny od 20 do 23 oraz od 0 do 5, a ___BLANK3___ to funkcja przeglądarki, która wywołuje tick() co intervalMs milisekund aż do clearInterval. Drugie wywołanie start() nie może uruchomić drugiej pętli, a stop() ją zatrzymuje.

  1. PytaniePure functions
  2. PytanieZarządzanie stanem
  3. Ułóż w kolejnościKroki implementacji niemutowalnego stanu
  4. Zadanie z kodemĆwiczenie: Panel sterowania parku
  5. PytanieCode splitting
  6. PytanieWzorzec Observer
  7. Kliknij w kolejnościSortowanie: Factory pattern
  8. Zadanie z kodemĆwiczenie: Symulacja czasu

Przydatne artykuły