Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura
Optymalizacja bundla - analiza i optymalizacja pakietów
W tej lekcji9
Wyobraź sobie ciężarówkę, która wiezie do parku jeden worek karmy, a ciągnie cały magazyn, bo nikt nie sprawdził paki. Optymalizacja bundla to kompleksowy proces analizy i optymalizacji pakietów JavaScript: mniejszy rozmiar, szybsze ładowanie i efektywne wykorzystanie zasobów przeglądarki. To ostatni krok po code splittingu, tree shakingu i lazy loadingu.
Dlaczego to ważne?
Poniższe liczby to hipotetyczny przykład, a nie wynik badań, ale pokazują, co mierzymy:
// Hipotetyczny przykład: liczby ilustracyjne, nie wyniki pomiarów
// Metryki wydajności przed optymalizacją
const beforeOptimization = {
bundleSize: '2.8MB',
firstContentfulPaint: '3.4s',
largestContentfulPaint: '5.1s',
timeToInteractive: '6.2s',
cumulativeLayoutShift: 0.25
};
// Metryki wydajności po optymalizacji
const afterOptimization = {
bundleSize: '420KB',
firstContentfulPaint: '0.9s',
largestContentfulPaint: '1.6s',
timeToInteractive: '2.1s',
cumulativeLayoutShift: 0.05
};
// Poprawa wydajności
const improvement = {
bundleSizeReduction: '85%',
fcpImprovement: '73%',
lcpImprovement: '69%',
ttiImprovement: '66%',
clsImprovement: '80%'
};
// Analiza kosztów business impact
const businessImpact = {
conversionRate: {
before: '2.1%',
after: '3.8%',
improvement: '+81%'
},
bounceRate: {
before: '68%',
after: '42%',
improvement: '-38%'
},
mobileUsersLost: {
before: '35%', // Przez wolne ładowanie
after: '12%',
improvement: '-66%'
},
revenueImpact: {
monthlyLoss: '$24,000', // Z powodu wolnych bundli
monthlyGain: '$45,000' // Po optymalizacji
}
};Do Core Web Vitals należą z nich LCP i CLS (trzecią jest INP), FCP to metryka pomocnicza, a TTI od Lighthouse 10 nie wlicza się do wyniku. Własne liczby zawsze zmierz.
Narzędzia do analizy bundli
Code splitting wdrażasz w czterech krokach: analiza rozmiaru bundla, wybór punktów podziału (split points), konfiguracja dynamicznych importów i weryfikacja ładowania chunków.
Webpack Bundle Analyzer
Webpack Bundle Analyzer rysuje mapę modułów i pokazuje, które zajmują najwięcej miejsca:
# Instalacja i użycie
npm install --save-dev webpack-bundle-analyzer
# Generowanie raportu (analyzer czyta plik statystyk webpacka)
npx webpack --profile --json=stats.json
npx webpack-bundle-analyzer stats.json
# Integracja z webpack config
const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
module.exports = {
plugins: [
new BundleAnalyzerPlugin({
analyzerMode: 'static',
openAnalyzer: false,
generateStatsFile: true,
reportFilename: 'bundle-report.html'
})
]
};Analyzer czyta plik statystyk (stats.json), a nie gotowe pliki .js.
Analiza w CI/CD
Workflow GitHub Actions sprawdza rozmiar przy każdym pushu i pull requeście:
# .github/workflows/bundle-analysis.yml
name: Bundle Analysis
on: [push, pull_request]
jobs:
analyze:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '22'
- name: Install dependencies
run: npm ci
- name: Build and analyze
run: |
npm run build
npx size-limit
- name: Upload bundle stats
uses: actions/upload-artifact@v4
with:
name: bundle-stats
path: dist/stats.jsonnpx size-limit (pakiety size-limit i @size-limit/file w devDependencies) przerywa build, gdy plik przekroczy limit z package.json.
Source Map Explorer
Source Map Explorer pokazuje, z których plików źródłowych składa się gotowy bundle:
# Analiza source map
npm install --global source-map-explorer
# Analiza konkretnego bundle
source-map-explorer bundle.js bundle.js.map
# Raport HTML (zachowaj go, by porównać z kolejną wersją)
source-map-explorer bundle.js --html report.htmlPorównywania wersji nie ma, więc raporty HTML zachowuj między wydaniami.
Webpack Dashboard
Webpack Dashboard zamienia surowy log webpacka w czytelny panel w terminalu:
// Interaktywny dashboard podczas development
const DashboardPlugin = require('webpack-dashboard/plugin');
module.exports = {
plugins: [
new DashboardPlugin()
]
};Panel pojawi się, gdy uruchomisz webpacka przez CLI pakietu, np. webpack-dashboard -- webpack --watch. Rozmiary modułów widzisz wtedy przy każdej zmianie.
Zaawansowane techniki optymalizacji
Strategie podziału na chunki
splitChunks dzieli node_modules na grupy (cache groups), które przeglądarka cache'uje niezależnie od kodu aplikacji:
// webpack.config.js - Zaawansowana konfiguracja chunks
module.exports = {
optimization: {
splitChunks: {
chunks: 'all',
minSize: 20000,
maxSize: 244000,
cacheGroups: {
// Framework chunks (React, Angular, Vue)
framework: {
test: /[\\/]node_modules[\\/](react|react-dom|@angular|vue)[\\/]/,
name: 'framework',
priority: 40,
enforce: true
},
// UI Libraries chunk
ui: {
test: /[\\/]node_modules[\\/](@mui|antd|bootstrap|@chakra-ui)[\\/]/,
name: 'ui-libs',
priority: 30,
enforce: true
},
// Utility libraries chunk
utils: {
test: /[\\/]node_modules[\\/](lodash|ramda|date-fns|moment)[\\/]/,
name: 'utils',
priority: 20,
enforce: true
},
// Common application code
common: {
name: 'common',
minChunks: 2,
priority: 10,
reuseExistingChunk: true
},
// Large libraries w osobnych chunkach
largeDeps: {
test: /[\\/]node_modules[\\/](monaco-editor|three|d3)[\\/]/,
name(module) {
const packageName = module.context.match(/[\\/]node_modules[\\/](.*?)([\\/]|$)/)[1];
return `lib.${packageName.replace('@', '')}`;
},
priority: 35,
enforce: true
}
}
}
}
};Wyższy priority wygrywa przy konflikcie grup, a enforce: true pomija progi rozmiaru. Po zmianie Twojego kodu użytkownik nie pobiera ponownie Reacta.
Module Federation dla mikrofrontendów
Module Federation, wbudowane w webpack 5, pozwala niezależnym aplikacjom dzielić się kodem w trakcie działania:
// webpack.config.js - Host application
const { ModuleFederationPlugin } = require('webpack').container;
module.exports = {
plugins: [
new ModuleFederationPlugin({
name: 'host',
filename: 'remoteEntry.js',
remotes: {
userDashboard: 'userDashboard@http://localhost:3001/remoteEntry.js',
productCatalog: 'productCatalog@http://localhost:3002/remoteEntry.js',
paymentSystem: 'paymentSystem@http://localhost:3003/remoteEntry.js'
},
shared: {
react: {
singleton: true,
requiredVersion: '^19.0.0',
eager: true
},
'react-dom': {
singleton: true,
requiredVersion: '^19.0.0',
eager: true
}
}
})
]
};
// Micro-frontend - User Dashboard
const { ModuleFederationPlugin } = require('webpack').container;
module.exports = {
plugins: [
new ModuleFederationPlugin({
name: 'userDashboard',
filename: 'remoteEntry.js',
exposes: {
'./UserProfile': './src/components/UserProfile',
'./UserSettings': './src/components/UserSettings'
},
shared: {
react: { singleton: true },
'react-dom': { singleton: true }
}
})
]
};singleton: true gwarantuje jedną kopię Reacta, a dwa module.exports to dwa osobne pliki konfiguracyjne.
Budowanie przyrostowe
Cache na dysku skraca kolejne buildy, bo webpack przebudowuje tylko to, co się zmieniło:
// Konfiguracja cache webpacka przyspieszająca kolejne buildy
const path = require('path');
module.exports = {
cache: {
type: 'filesystem',
cacheDirectory: path.resolve(__dirname, '.webpack-cache'),
buildDependencies: {
config: [__filename],
tsconfig: [path.resolve(__dirname, 'tsconfig.json')],
packagejson: [path.resolve(__dirname, 'package.json')]
},
version: '1.0',
store: 'pack',
compression: 'gzip'
},
// Persistent cache dla node_modules
snapshot: {
managedPaths: [path.resolve(__dirname, 'node_modules')],
buildDependencies: {
hash: true,
timestamp: true
},
module: {
timestamp: true
},
resolve: {
timestamp: true
}
}
};buildDependencies wskazuje pliki, których zmiana unieważnia cache.
Budżety i monitoring
Konfiguracja budżetu
Budżet wydajności (performance budget) to limit rozmiaru, który narzędzie size-limit czyta z package.json:
{
"size-limit": [
{
"path": "./dist/js/main.*.js",
"limit": "170 kB",
"gzip": true
},
{
"path": "./dist/js/vendor.*.js",
"limit": "300 kB",
"gzip": true
},
{
"path": "./dist/css/*.css",
"limit": "50 kB",
"gzip": true
},
{
"path": "./dist/js/runtime.*.js",
"limit": "10 kB",
"gzip": true
}
]
}Limity dotyczą rozmiaru po gzip. Pierwszą linię usuń, bo JSON nie ma komentarzy.
Automatyczne monitorowanie wydajności
Monitor zbiera czasy ładowania z Performance API u prawdziwych użytkowników i porównuje je z progami:
// Performance monitoring service
class BundlePerformanceMonitor {
constructor() {
this.metrics = {
bundleSizes: new Map(),
loadTimes: new Map(),
cacheHitRates: new Map()
};
this.thresholds = {
maxBundleSize: 250000, // 250KB
maxLoadTime: 3000, // 3s
minCacheHitRate: 80 // 80%
};
}
async measureBundlePerformance() {
const performanceData = {
timestamp: Date.now(),
metrics: await this.collectMetrics(),
violations: this.checkViolations(),
recommendations: this.generateRecommendations()
};
await this.sendToMonitoring(performanceData);
return performanceData;
}
async collectMetrics() {
const bundleEntries = performance.getEntriesByType('navigation');
const resourceEntries = performance.getEntriesByType('resource');
return {
pageLoadTime: bundleEntries[0]?.loadEventEnd - bundleEntries[0]?.fetchStart,
resourceLoadTimes: resourceEntries
.filter(entry => entry.name.includes('.js') || entry.name.includes('.css'))
.map(entry => ({
name: entry.name,
size: entry.transferSize,
loadTime: entry.responseEnd - entry.fetchStart,
cached: entry.transferSize === 0
})),
memoryUsage: performance.memory ? {
used: performance.memory.usedJSHeapSize,
total: performance.memory.totalJSHeapSize,
limit: performance.memory.jsHeapSizeLimit
} : null
};
}
checkViolations() {
const violations = [];
// Sprawdzenie rozmiarów bundli (transferSize z Resource Timing)
performance.getEntriesByType('resource')
.filter(entry => entry.name.includes('.js'))
.forEach(({ name: bundleName, transferSize: size }) => {
if (size > this.thresholds.maxBundleSize) {
violations.push({
type: 'SIZE_VIOLATION',
bundle: bundleName,
current: size,
threshold: this.thresholds.maxBundleSize,
severity: 'HIGH'
});
}
});
return violations;
}
generateRecommendations() {
const recommendations = [];
// Analiza duplikatów w bundlach
const duplicatedModules = this.findDuplicatedModules();
if (duplicatedModules.length > 0) {
recommendations.push({
type: 'REMOVE_DUPLICATES',
modules: duplicatedModules,
estimatedSavings: this.calculateDuplicateSavings(duplicatedModules)
});
}
// Analiza nieużywanych dependencji
const unusedDeps = this.findUnusedDependencies();
if (unusedDeps.length > 0) {
recommendations.push({
type: 'REMOVE_UNUSED_DEPS',
dependencies: unusedDeps,
estimatedSavings: this.calculateUnusedDepsSavings(unusedDeps)
});
}
return recommendations;
}
}
// Automatyczne monitorowanie w production
if (typeof window !== 'undefined' && process.env.NODE_ENV === 'production') {
const monitor = new BundlePerformanceMonitor();
// Pomiar po załadowaniu strony
window.addEventListener('load', () => {
setTimeout(() => {
monitor.measureBundlePerformance();
}, 2000);
});
}performance.memory istnieje tylko w Chromium, stąd sprawdzenie przed użyciem. Metody pomocnicze (sendToMonitoring, findDuplicatedModules, findUnusedDependencies i te liczące oszczędności) piszesz sam.
Real User Monitoring (RUM)
PerformanceObserver powiadamia o każdym pobranym pliku i o długich zadaniach (long tasks):
// RUM dla bundle performance
class RealUserBundleMonitoring {
constructor() {
this.sessionId = this.generateSessionId();
this.startTime = performance.now();
this.setupObservers();
}
setupObservers() {
// Performance Observer dla resource timing
if ('PerformanceObserver' in window) {
const observer = new PerformanceObserver((list) => {
list.getEntries().forEach(entry => {
if (entry.name.includes('.js') || entry.name.includes('.css')) {
this.trackResourceLoad(entry);
}
});
});
observer.observe({ entryTypes: ['resource'] });
}
// Long task observer
if ('PerformanceObserver' in window) {
const longTaskObserver = new PerformanceObserver((list) => {
list.getEntries().forEach(entry => {
this.trackLongTask(entry);
});
});
longTaskObserver.observe({ entryTypes: ['longtask'] });
}
}
trackResourceLoad(entry) {
const resourceData = {
sessionId: this.sessionId,
timestamp: Date.now(),
resourceType: entry.name.includes('.js') ? 'javascript' : 'css',
resourceName: entry.name,
loadTime: entry.responseEnd - entry.fetchStart,
transferSize: entry.transferSize,
cached: entry.transferSize === 0,
userAgent: navigator.userAgent,
connectionType: navigator.connection?.effectiveType
};
this.sendMetric('resource_load', resourceData);
}
trackLongTask(entry) {
const longTaskData = {
sessionId: this.sessionId,
timestamp: Date.now(),
duration: entry.duration,
startTime: entry.startTime,
attribution: entry.attribution
};
this.sendMetric('long_task', longTaskData);
}
async sendMetric(type, data) {
// Wysyłanie do systemu analytics
if (navigator.sendBeacon) {
navigator.sendBeacon('/api/metrics', JSON.stringify({
type,
data,
metadata: {
url: window.location.href,
timestamp: Date.now(),
sessionId: this.sessionId
}
}));
}
}
}Long task blokuje główny wątek co najmniej 50 ms, a sendBeacon działa nawet przy zamykaniu karty.
Optymalizacja specyficznych bibliotek
Optymalizacja Lodasha
Tu wraca tree shaking, czyli automatyczne usuwanie nieużywanego kodu (dead code) z finalnego bundla. Działa na modułach ES, bo import i export są statyczne, w przeciwieństwie do require z CommonJS. Pole "sideEffects": false w package.json mówi bundlerowi, że moduły paczki nie mają efektów ubocznych, więc nieużywane może pominąć. Klasyczny Lodash to CommonJS:
# Budowa modułowej wersji Lodash w formacie modułów ES (tak powstaje lodash-es)
npx lodash-cli modularize exports=es
# Babel plugin dla automatycznej optymalizacji
npm install --save-dev babel-plugin-lodashDruga część to wtyczka Babel, która zamienia import całej biblioteki na importy pojedynczych funkcji:
// babel.config.js
module.exports = {
plugins: [
'lodash' // Automatycznie zamienia importy na cherry-picked
]
};
// Przed optymalizacją (70KB)
import _ from 'lodash';
// Po optymalizacji (2KB)
import debounce from 'lodash/debounce';
import throttle from 'lodash/throttle';Dziś prościej sięgnąć po lodash-es. Z tego samego powodu wzorca Module z IIFE, choć ukrywa prywatne zmienne, nie da się przyciąć, bo jest jednym obiektem.
Optymalizacja bibliotek do dat
Moment.js nie wspiera tree shakingu, a jego autorzy sami polecają nowsze alternatywy:
// Porównanie rozmiarów bibliotek dat (orientacyjne, zależą od wersji; aktualne sprawdzisz np. w bundlephobia)
const dateLibraryComparison = {
'moment': {
size: '230KB',
gzipped: '67KB',
treeshaking: false
},
'date-fns': {
size: '78KB',
gzipped: '13KB',
treeshaking: true
},
'dayjs': {
size: '9KB',
gzipped: '3KB',
treeshaking: true
},
'luxon': {
size: '67KB',
gzipped: '19KB',
treeshaking: true
}
};
// Migration guide z Moment.js do date-fns
const migrationExamples = {
before: `
import moment from 'moment';
const formatted = moment().format('DD/MM/YYYY');
const isAfter = moment(date1).isAfter(date2);
`,
after: `
import { format, isAfter } from 'date-fns';
import { pl } from 'date-fns/locale';
const formatted = format(new Date(), 'dd/MM/yyyy', { locale: pl });
const isAfterResult = isAfter(date1, date2);
`
};Rozmiary są orientacyjne. Uwaga na tokeny: date-fns używa dd i yyyy, a Moment DD i YYYY.
Optymalizacja frameworków CSS
PurgeCSS skanuje pliki źródłowe i usuwa selektory CSS, których w nich nie znalazł:
// PurgeCSS dla usuwania nieużywanych styli
const purgecss = require('@fullhuman/postcss-purgecss');
module.exports = {
plugins: [
purgecss({
content: [
'./src/**/*.html',
'./src/**/*.js',
'./src/**/*.tsx'
],
safelist: [
/^tooltip-/,
/^modal-/,
/^dropdown-/
],
defaultExtractor: content => content.match(/[\w-/:]+(?<!:)/g) || []
})
]
};
// Przykładowe redukcje rozmiaru (wartości ilustracyjne, zależą od projektu)
const cssOptimizationResults = {
bootstrap: {
before: '150KB',
after: '23KB',
reduction: '85%'
},
tailwind: {
before: '3.2MB',
after: '12KB',
reduction: '99.6%'
},
materialUI: {
before: '890KB',
after: '145KB',
reduction: '84%'
}
};safelist chroni klasy dodawane dynamicznie przez JavaScript.
Zaawansowana optymalizacja webpacka
Własne pluginy webpacka
Własny plugin to klasa z metodą apply, która podpina się pod hooki kompilatora:
// Plugin do analizy i optymalizacji bundle
class BundleOptimizationPlugin {
constructor(options = {}) {
this.options = {
reportPath: 'bundle-optimization-report.json',
thresholds: {
maxChunkSize: 250000,
maxModuleSize: 50000
},
...options
};
}
apply(compiler) {
compiler.hooks.emit.tapAsync('BundleOptimizationPlugin', (compilation, callback) => {
const report = this.generateOptimizationReport(compilation);
// Zapisz raport
compilation.assets[this.options.reportPath] = {
source: () => JSON.stringify(report, null, 2),
size: () => JSON.stringify(report, null, 2).length
};
// Loguj ostrzeżenia
this.logWarnings(compilation, report);
callback();
});
}
generateOptimizationReport(compilation) {
const chunks = Array.from(compilation.chunks);
const modules = Array.from(compilation.modules);
return {
timestamp: new Date().toISOString(),
summary: {
totalChunks: chunks.length,
totalModules: modules.length,
totalSize: this.calculateTotalSize(chunks)
},
chunks: chunks.map(chunk => ({
id: chunk.id,
name: chunk.name,
size: chunk.size,
modules: chunk.getModules().length,
parents: Array.from(chunk.groupsIterable, g => g.getParents()),
children: Array.from(chunk.groupsIterable, g => g.getChildren())
})),
optimizationOpportunities: this.findOptimizationOpportunities(chunks, modules),
recommendations: this.generateRecommendations(chunks, modules)
};
}
findOptimizationOpportunities(chunks, modules) {
const opportunities = [];
// Znajdź duże moduły
const largeModules = modules.filter(module =>
module.size() > this.options.thresholds.maxModuleSize
);
if (largeModules.length > 0) {
opportunities.push({
type: 'LARGE_MODULES',
modules: largeModules.map(m => ({
identifier: m.identifier(),
size: m.size(),
reasons: m.reasons.map(r => r.module?.identifier())
}))
});
}
// Znajdź duplikaty
const moduleDuplicates = this.findModuleDuplicates(modules);
if (moduleDuplicates.length > 0) {
opportunities.push({
type: 'MODULE_DUPLICATES',
duplicates: moduleDuplicates
});
}
return opportunities;
}
}
// Użycie plugin
module.exports = {
plugins: [
new BundleOptimizationPlugin({
thresholds: {
maxChunkSize: 200000,
maxModuleSize: 30000
}
})
]
};To szkic w API webpacka 4, a metody pomocnicze (calculateTotalSize, findModuleDuplicates, generateRecommendations, logWarnings) piszesz sam. W webpacku 5 zasoby dodajesz w hooku processAssets przez compilation.emitAsset, rozmiar chunka podaje compilation.chunkGraph.getChunkSize(chunk), a zamiast usuniętego module.reasons używasz compilation.moduleGraph.getIncomingConnections(module).
Optymalizacja chunka runtime
Runtime to kod webpacka ładujący chunki, a wydzielony nie unieważnia cache aplikacji. Obok minifikacja JS i CSS:
// Optymalizacja runtime chunk
const TerserPlugin = require('terser-webpack-plugin');
const CssMinimizerPlugin = require('css-minimizer-webpack-plugin');
module.exports = {
optimization: {
runtimeChunk: {
name: entrypoint => `runtime-${entrypoint.name}`
},
// Minimizer configuration
minimizer: [
new TerserPlugin({
parallel: true,
terserOptions: {
parse: {
ecma: 2020
},
compress: {
ecma: 2020,
comparisons: false,
inline: 2,
drop_console: process.env.NODE_ENV === 'production',
drop_debugger: process.env.NODE_ENV === 'production',
pure_funcs: ['console.log', 'console.info', 'console.debug']
},
mangle: {
safari10: true
},
output: {
ecma: 2020,
comments: false,
ascii_only: true
}
}
}),
new CssMinimizerPlugin({
parallel: true,
minimizerOptions: {
preset: [
'default',
{
discardComments: { removeAll: true },
normalizeWhitespace: true,
colormin: true,
convertValues: true,
discardDuplicates: true,
discardEmpty: true,
mergeRules: true,
minifyFontValues: true,
minifyGradients: true,
minifyParams: true,
minifySelectors: true,
normalizeCharset: true,
normalizeDisplayValues: true,
normalizePositions: true,
normalizeRepeatStyle: true,
normalizeString: true,
normalizeTimingFunctions: true,
normalizeUnicode: true,
normalizeUrl: true,
orderedValues: true,
reduceIdents: true,
reduceInitial: true,
reduceTransforms: true,
svgo: true,
uniqueSelectors: true
}
]
}
})
]
}
};drop_console działa tylko w produkcji, a pure_funcs wskazuje funkcje, których wywołania można wyciąć.
Testy bundla
Automatyczne testy bundla
Optymalizację łatwo zepsuć jednym importem, więc pilnują jej testy rozmiaru, duplikatów i tree shakingu:
// Test suite dla bundle optimization
const bundleTests = {
// Test rozmiaru bundle
async testBundleSize() {
const bundleStats = await getBundleStats();
const maxSize = 500000; // 500KB
expect(bundleStats.totalSize).toBeLessThan(maxSize);
expect(bundleStats.mainChunk).toBeLessThan(200000);
expect(bundleStats.vendorChunk).toBeLessThan(300000);
},
// Test duplikatów
async testNoDuplicateModules() {
const bundleAnalysis = await analyzeBundleContent();
const duplicates = bundleAnalysis.duplicatedModules;
expect(duplicates).toHaveLength(0);
},
// Test tree shaking effectiveness
async testTreeShakingEffectiveness() {
const unusedExports = await findUnusedExports();
const deadCode = await findDeadCode();
expect(unusedExports.length).toBeLessThan(5);
expect(deadCode.totalSize).toBeLessThan(10000);
},
// Test cache effectiveness
async testCacheability() {
const chunks = await getChunkManifest();
chunks.forEach(chunk => {
if (chunk.type === 'vendor') {
expect(chunk.hash).toMatch(/^[a-f0-9]{8}$/);
expect(chunk.cacheable).toBe(true);
}
});
}
};
// Integration z CI/CD
describe('Bundle Optimization Tests', () => {
test('Bundle size within limits', bundleTests.testBundleSize);
test('No duplicate modules', bundleTests.testNoDuplicateModules);
test('Tree shaking effective', bundleTests.testTreeShakingEffectiveness);
test('Chunks properly cacheable', bundleTests.testCacheability);
});Funkcje pomocnicze, jak getBundleStats, piszesz sam na podstawie stats.json.
Wykrywanie regresji wydajności
Detektor regresji porównuje bieżące metryki z zapisanym punktem odniesienia (baseline):
// System do wykrywania regresji wydajności
class PerformanceRegressionDetector {
constructor() {
this.baselineMetrics = null;
this.threshold = 0.1; // 10% wzrost = regresja
}
async setBaseline() {
this.baselineMetrics = await this.measureCurrentMetrics();
await this.saveBaseline(this.baselineMetrics);
}
async detectRegressions() {
const currentMetrics = await this.measureCurrentMetrics();
const regressions = [];
if (!this.baselineMetrics) {
this.baselineMetrics = await this.loadBaseline();
}
// Sprawdź rozmiary bundli
const sizeRegression = this.detectSizeRegression(
this.baselineMetrics.bundleSize,
currentMetrics.bundleSize
);
if (sizeRegression) {
regressions.push(sizeRegression);
}
// Sprawdź czasy ładowania
const loadTimeRegression = this.detectLoadTimeRegression(
this.baselineMetrics.loadTime,
currentMetrics.loadTime
);
if (loadTimeRegression) {
regressions.push(loadTimeRegression);
}
return regressions;
}
detectSizeRegression(baseline, current) {
const increase = (current - baseline) / baseline;
if (increase > this.threshold) {
return {
type: 'SIZE_REGRESSION',
baseline: baseline,
current: current,
increase: `${(increase * 100).toFixed(1)}%`,
severity: increase > 0.25 ? 'HIGH' : 'MEDIUM'
};
}
return null;
}
async generateRegressionReport(regressions) {
return {
timestamp: new Date().toISOString(),
regressions: regressions,
recommendations: await this.generateRecommendations(regressions),
actionItems: this.generateActionItems(regressions)
};
}
}Wzrost ponad 10% oznacza regresję, a ponad 25% regresję o wysokim priorytecie.
Strategie wdrożeń produkcyjnych
Nowy bundle możesz wypuszczać stopniowo i porównywać warianty na prawdziwym ruchu:
// Strategia progressive deployment dla bundli
class ProgressiveBundleDeployment {
constructor() {
this.deploymentStages = [
{ name: 'canary', percentage: 5 },
{ name: 'blue-green', percentage: 50 },
{ name: 'full', percentage: 100 }
];
}
async deployNewBundle(bundleVersion) {
for (const stage of this.deploymentStages) {
console.log(`Deploying to ${stage.name} (${stage.percentage}% traffic)`);
await this.deployToStage(bundleVersion, stage);
const metrics = await this.monitorStageMetrics(stage, 300000); // 5 min
if (!this.validateStageSuccess(metrics)) {
await this.rollbackStage(stage);
throw new Error(`Deployment failed at ${stage.name} stage`);
}
console.log(`Stage ${stage.name} successful`);
}
}
async monitorStageMetrics(stage, duration) {
const startTime = Date.now();
const metrics = {
errorRate: [],
loadTimes: [],
bundleErrors: []
};
while (Date.now() - startTime < duration) {
const sample = await this.collectMetricsSample(stage);
metrics.errorRate.push(sample.errorRate);
metrics.loadTimes.push(sample.avgLoadTime);
metrics.bundleErrors.push(sample.bundleErrors);
await new Promise(resolve => setTimeout(resolve, 30000)); // 30s intervals
}
return metrics;
}
validateStageSuccess(metrics) {
const avgErrorRate = metrics.errorRate.reduce((a, b) => a + b) / metrics.errorRate.length;
const avgLoadTime = metrics.loadTimes.reduce((a, b) => a + b) / metrics.loadTimes.length;
const totalBundleErrors = metrics.bundleErrors.reduce((a, b) => a + b);
return avgErrorRate < 0.01 && // < 1% error rate
avgLoadTime < 3000 && // < 3s load time
totalBundleErrors < 5; // < 5 bundle errors
}
}
// A/B testing różnych strategii bundle optimization
class BundleOptimizationABTest {
constructor() {
this.variants = {
control: {
strategy: 'current',
splitChunks: 'default',
compression: 'gzip'
},
optimized: {
strategy: 'aggressive_splitting',
splitChunks: 'custom',
compression: 'brotli'
},
experimental: {
strategy: 'module_federation',
splitChunks: 'micro_chunks',
compression: 'zstd'
}
};
}
async runABTest(duration = 7 * 24 * 60 * 60 * 1000) { // 7 days
const testId = this.generateTestId();
// Rozpocznij test
await this.startTest(testId);
// Monitoruj metryki
const results = await this.monitorTest(testId, duration);
// Analizuj wyniki
const analysis = await this.analyzeResults(results);
// Wybierz zwycięzcę
const winner = this.selectWinner(analysis);
return {
testId,
duration,
results,
analysis,
winner,
recommendation: this.generateRecommendation(analysis, winner)
};
}
async monitorTest(testId, duration) {
const results = {
control: { metrics: [], samples: 0 },
optimized: { metrics: [], samples: 0 },
experimental: { metrics: [], samples: 0 }
};
const startTime = Date.now();
while (Date.now() - startTime < duration) {
for (const variant of Object.keys(this.variants)) {
const metrics = await this.collectVariantMetrics(variant);
results[variant].metrics.push(metrics);
results[variant].samples++;
}
await new Promise(resolve => setTimeout(resolve, 3600000)); // 1 hour
}
return results;
}
selectWinner(analysis) {
const scores = {};
for (const variant of Object.keys(analysis)) {
const data = analysis[variant];
scores[variant] = (
(1 / data.avgLoadTime) * 0.4 + // 40% weight
(1 / data.avgBundleSize) * 0.3 + // 30% weight
data.conversionRate * 0.2 + // 20% weight
(1 - data.errorRate) * 0.1 // 10% weight
);
}
return Object.keys(scores).reduce((a, b) =>
scores[a] > scores[b] ? a : b
);
}
}Etap blue-green to uproszczenie: klasyczne blue-green przełącza cały ruch naraz, a stopniowe zwiększanie ruchu to canary release.
Podsumowanie i lista kontrolna
Na koniec lista kontrolna i hipotetyczny rachunek zwrotu z inwestycji:
const bundleOptimizationChecklist = {
analysis: [
'Webpack Bundle Analyzer setup',
'Source map analysis',
'Performance budget configured',
'CI/CD bundle size monitoring',
'Duplicate detection'
],
codeOptimization: [
'Tree shaking enabled',
'Dead code elimination',
'Unused dependencies removed',
'Code splitting implemented',
'Lazy loading configured'
],
bundleStrategy: [
'Chunk splitting optimized',
'Vendor chunks separated',
'Runtime chunk extracted',
'Common chunks identified',
'Dynamic imports utilized'
],
compression: [
'Gzip/Brotli enabled',
'Minification configured',
'CSS optimization',
'Image optimization',
'Font optimization'
],
caching: [
'Long-term caching setup',
'Content-based hashing',
'Cache invalidation strategy',
'Service worker implemented',
'CDN optimization'
],
monitoring: [
'Real user monitoring',
'Performance metrics tracking',
'Regression detection',
'A/B testing capability',
'Alert system configured'
]
};
// Hipotetyczne ROI (wartości ilustracyjne, nie dane z badań)
const optimizationROI = {
investment: {
developmentTime: '2-3 weeks',
toolingSetup: '$5,000',
ongoingMaintenance: '$2,000/month'
},
returns: {
conversionRateIncrease: '+25-40%',
bounceRateDecrease: '-30-50%',
serverCostReduction: '-20-30%',
mobileUserRetention: '+35-60%',
seoRankingImprovement: '+15-25%'
},
businessImpact: {
revenueIncrease: '$50,000-150,000/year',
costSavings: '$20,000-40,000/year',
paybackPeriod: '2-4 months',
totalROI: '400-800%'
}
};Optymalizacja zwykle się opłaca, ale zwrot zależy od projektu, więc opieraj się na własnych pomiarach. Zacznij od Bundle Analyzera bo jedna mapa modułów zwykle wskazuje największego winowajcę. W edytorze poniżej zbudujesz dashboard parku, a w kolejnej lekcji poznasz architekturę opartą na zdarzeniach.
Pamiętaj: każdy kilobajt w bundlu to ładunek, który zwiedzający muszą przewieźć przez bramę, więc pakuj tylko to, co niezbędne.
Kod do tej lekcji: index.js
// Dashboard i Interfejs Parku
// Ćwiczenie: Zaimplementuj system renderowania dashboardu
class ParkDashboard {
constructor() {
this.widgets = [];
this.data = {};
}
// Zaimplementuj metody:
// addWidget(name, renderFn) - dodaj widget
// updateData(key, value) - zaktualizuj dane
// render() - wyrenderuj wszystkie widgety
addWidget(name, renderFn) {
// Twój kod tutaj
}
updateData(key, value) {
// Twój kod tutaj
}
render() {
// Twój kod tutaj
}
}
const dashboard = new ParkDashboard();
console.log("Dashboard gotowy do konfiguracji");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. Co to jest tree shaking w kontekście bundlowania JavaScript?
2. Który format modułów umożliwia efektywne tree shaking?
To 2 z 6 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj etapy refaktoryzacji kodu do wzorca projektowego:
- Edytor kodu
W pliku index.js są trzy testy jednostkowe: funkcje, które dostają klasę do sprawdzenia i mają zwrócić true dla poprawnej klasy, a false dla klasy z błędem. Uzupełnij luki: ___BLANK1___ to operator porównania, który sprawdza, że getModule zwraca ten sam obiekt, który zarejestrowano, ___BLANK2___ to operator porównania, który sprawdza, że dwa id są różne, a ___BLANK3___ to liczba alertów, których oczekujemy, gdy tylko jeden z dwóch sensorów przekracza próg. Sprawdzarka uruchomi Twoje testy na poprawnych klasach ParkCore, DinosaurRegistry i SecuritySystem oraz na wersjach z błędami (kopia modułu zamiast oryginału, jedno id dla wszystkich, alarm przy odczycie równym progowi).
- Układanie w pionie
Ułóż elementy interfejsu w kolejności, w jakiej pojawiają się w kodzie HTML strony (od zewnętrznego kontenera):
- Edytor kodu
W pliku index.js jest klasa PerformanceMonitor. Uzupełnij luki: ___BLANK1___ to metoda obiektu performance, która zwraca bieżący czas w milisekundach o wysokiej precyzji (tą samą metodą measure liczy czas końca), ___BLANK2___ to metoda tablicy, która sumuje wszystkie czasy (startuje od 0), a ___BLANK3___ to metoda Math, która zwraca największy z czasów. measure(name, fn) ma zwrócić wynik fn i zapisać pomiar { name, duration }, a getReport(name) zwrócić { count, min, max, avg } dla pomiarów o tej nazwie albo null, gdy ich nie ma.
- Klikanie w kolejności
Ułóż kroki implementacji lazy loading komponentu w JavaScript:
- Układanie w poziomie
Ułóż elementy eksportu modułu w odpowiedniej kolejności:
- Klikanie w kolejności
Ułóż elementy wzorca Observer:
- Układanie w pionie
Ułóż kroki implementacji wzorca Factory w odpowiedniej kolejności:
- Układanie w pionie
Ułóż przepływ danych w systemie zarządzania dinozaurami:
- Układanie w pionie
Ułóż elementy wstrzykiwania zależności w odpowiedniej kolejności:
- Układanie w pionie
Ułóż etapy wdrażania code splitting w aplikacji:
- Układanie w pionie
Ułóż etapy implementacji wzorca Observer w aplikacji:
- Układanie w poziomie
Ułóż elementy zamrażania obiektu:
Zadania po tej lekcji
- Ułóż w kolejnościEtapy refaktoryzacji do wzorca projektowego
- PytanieTree shaking
- PytanieWarunki tree shaking
- Zadanie z kodemĆwiczenie: Testy jednostkowe
- Ułóż w kolejnościSortowanie pionowe: Komponenty UI
- Zadanie z kodemĆwiczenie: Monitor wydajności
- PytanieAnaliza bundla
- Kliknij w kolejnościLazy loading komponentu
- Ułóż w kolejnościKolejność: Wzorzec Module export
- Kliknij w kolejnościSortowanie: Observer pattern
- PytanieNarzędzie do analizy bundla
- Ułóż w kolejnościImplementacja wzorca Factory
- Ułóż w kolejnościSortowanie pionowe: przepływ danych
- Ułóż w kolejnościKolejność: Dependency Injection
- PytaniePole sideEffects w package.json
- Ułóż w kolejnościEtapy code splitting
- Ułóż w kolejnościEtapy wdrażania wzorca Observer
- PytanieCel wzorca IIFE Module
- Ułóż w kolejnościSkładnia Object.freeze