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

Optymalizacja bundla - analiza i optymalizacja pakietów

17 min czytania ·
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.json

npx 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.html

Poró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-lodash

Druga 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. 1. Co to jest tree shaking w kontekście bundlowania JavaScript?

  2. 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:

  1. Ułóż w kolejnościEtapy refaktoryzacji do wzorca projektowego
  2. PytanieTree shaking
  3. PytanieWarunki tree shaking
  4. Zadanie z kodemĆwiczenie: Testy jednostkowe
  5. Ułóż w kolejnościSortowanie pionowe: Komponenty UI
  6. Zadanie z kodemĆwiczenie: Monitor wydajności
  7. PytanieAnaliza bundla
  8. Kliknij w kolejnościLazy loading komponentu
  9. Ułóż w kolejnościKolejność: Wzorzec Module export
  10. Kliknij w kolejnościSortowanie: Observer pattern
  11. PytanieNarzędzie do analizy bundla
  12. Ułóż w kolejnościImplementacja wzorca Factory
  13. Ułóż w kolejnościSortowanie pionowe: przepływ danych
  14. Ułóż w kolejnościKolejność: Dependency Injection
  15. PytaniePole sideEffects w package.json
  16. Ułóż w kolejnościEtapy code splitting
  17. Ułóż w kolejnościEtapy wdrażania wzorca Observer
  18. PytanieCel wzorca IIFE Module
  19. Ułóż w kolejnościSkładnia Object.freeze

Przydatne artykuły