Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura
Code splitting i tree shaking
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 potrzebnyRodzaje 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
- 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');- 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;
});- 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-es2. Webpack Bundle Analyzer
npm install --save-dev webpack-bundle-analyzer
npx webpack --profile --json=stats.json
npx webpack-bundle-analyzer stats.json3. Lighthouse CI dla monitorowania
# .github/workflows/lighthouse.yml
- name: Lighthouse CI
run: |
npm install -g @lhci/cli
lhci autorunPrzykł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:
- Zmniejszyć początkowy rozmiar bundla - użytkownicy pobierają tylko kod potrzebny do pierwszego renderu
- Przyspieszyć czas ładowania - mniejsze pliki = szybsze pobieranie
- Poprawić User Experience - aplikacja działa szybciej i płynniej
- Zaoszczędzić transfer danych - szczególnie ważne na mobilnych urządzeniach
- 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. Czym charakteryzuje się pure function (czysta funkcja)?
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.