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

Lazy loading - obrazów, tras, komponentów

15 min czytania ·
W tej lekcji8

Wyobraź sobie zwiedzającego, który przy bramie parku musi odebrać mapy wszystkich sektorów, zanim zrobi pierwszy krok. Tak działa aplikacja ładująca wszystko na starcie. Lazy loading to strategia optymalizacji polegająca na opóźnieniu ładowania zasobów do momentu, gdy stają się rzeczywiście potrzebne: gdy użytkownik przewija stronę, przechodzi na nową trasę albo wykonuje akcję wymagającą określonego komponentu.

Zalety lazy loading

Zyskujesz szybsze pierwsze ładowanie: mniejszy początkowy bundle, szybsze renderowanie pierwszej zawartości (FCP) i lepszą percepcję wydajności. Oszczędzasz pamięć RAM, transfer danych i baterię urządzeń mobilnych. Użytkownik dostaje płynne przewijanie, progresywne ładowanie treści i adaptację do możliwości urządzenia oraz połączenia.

Lazy loading obrazów

Natywny lazy loading w HTML

Najprostszy sposób nie wymaga JavaScriptu. Atrybut loading mówi przeglądarce, kiedy pobrać obraz:

<!-- Natywny lazy loading dla obrazów poniżej pierwszego ekranu (wspierany przez nowoczesne przeglądarki) -->
<img src="gallery-photo.jpg" alt="Zdjęcie w galerii" loading="lazy" />

<!-- Eager loading dla obrazów above-the-fold -->
<img src="logo.jpg" alt="Logo" loading="eager" />

<!-- Bez atrybutu: domyślnie eager (wartości "auto" nie ma w standardzie HTML) -->
<img src="banner.jpg" alt="Banner" />

Standard zna tylko wartości lazy i domyślne eager. Obrazów widocznych od razu nie oznaczaj jako lazy, bo opóźnisz największy element strony, a podając width i height, unikniesz przesunięć układu.

Intersection Observer API

Gdy potrzebujesz więcej kontroli, użyj Intersection Observer. To API zgłasza wejście elementu w obszar widoku (viewport) bez nasłuchiwania na każde przewinięcie:

// Implementacja lazy loading z Intersection Observer
class LazyImageLoader {
  constructor() {
    this.imageObserver = new IntersectionObserver(
      this.handleIntersection.bind(this),
      {
        root: null, // viewport
        rootMargin: '50px', // ładuj 50px przed wejściem w viewport
        threshold: 0.1 // trigger gdy 10% obrazu jest widoczne
      }
    );

    this.initLazyImages();
  }

  initLazyImages() {
    const lazyImages = document.querySelectorAll('img[data-src]');
    lazyImages.forEach(img => {
      this.imageObserver.observe(img);
    });
  }

  handleIntersection(entries) {
    entries.forEach(entry => {
      if (entry.isIntersecting) {
        const img = entry.target;
        this.loadImage(img);
        this.imageObserver.unobserve(img);
      }
    });
  }

  loadImage(img) {
    // Ładowanie obrazu z atrybutu data-src
    img.src = img.dataset.src;
    img.classList.add('loaded');

    // Usuwanie data-src po załadowaniu
    delete img.dataset.src;

    // Obsługa błędów ładowania
    img.onerror = () => {
      img.src = '/images/error-placeholder.png';
      img.classList.add('error');
    };
  }
}

// Inicjalizacja
document.addEventListener('DOMContentLoaded', () => {
  new LazyImageLoader();
});

Adres czeka w data-src do wejścia w widok, a unobserve sprawia, że obraz ładuje się tylko raz.

React komponenty dla lazy loading obrazów

W React tę logikę zamykamy w hooku useIntersectionObserver i komponencie LazyImage:

// Hook dla lazy loading obrazów
import { useState, useRef, useEffect } from 'react';

function useIntersectionObserver(options = {}) {
  const [isIntersecting, setIsIntersecting] = useState(false);
  const [hasIntersected, setHasIntersected] = useState(false);
  const elementRef = useRef(null);

  useEffect(() => {
    const element = elementRef.current;
    if (!element) return;

    const observer = new IntersectionObserver(
      ([entry]) => {
        const isElementIntersecting = entry.isIntersecting;
        setIsIntersecting(isElementIntersecting);

        if (isElementIntersecting && !hasIntersected) {
          setHasIntersected(true);
        }
      },
      { threshold: 0.1, rootMargin: '50px', ...options }
    );

    observer.observe(element);

    return () => observer.disconnect();
  }, [hasIntersected, options]);

  return { elementRef, isIntersecting, hasIntersected };
}

// Komponent LazyImage
function LazyImage({ src, alt, placeholder, className = '' }) {
  const [imageLoaded, setImageLoaded] = useState(false);
  const [imageError, setImageError] = useState(false);
  const { elementRef, hasIntersected } = useIntersectionObserver();

  const handleImageLoad = () => {
    setImageLoaded(true);
  };

  const handleImageError = () => {
    setImageError(true);
  };

  return (
    <div ref={elementRef} className={`lazy-image-container ${className}`}>
      {/* Placeholder wyświetlany podczas ładowania */}
      {!imageLoaded && (
        <img
          src={placeholder}
          alt={`${alt} placeholder`}
          className="placeholder-image"
        />
      )}

      {/* Rzeczywisty obraz ładowany lazy */}
      {hasIntersected && (
        <img
          src={imageError ? '/images/error.png' : src}
          alt={alt}
          onLoad={handleImageLoad}
          onError={handleImageError}
          className={`lazy-image ${imageLoaded ? 'loaded' : 'loading'}`}
        />
      )}

      {/* Loading spinner */}
      {hasIntersected && !imageLoaded && !imageError && (
        <div className="image-spinner">Ładowanie...</div>
      )}
    </div>
  );
}

// Użycie komponentu
function Gallery({ images }) {
  return (
    <div className="gallery">
      {images.map((image, index) => (
        <LazyImage
          key={index}
          src={image.url}
          alt={image.alt}
          placeholder={image.placeholder}
          className="gallery-item"
        />
      ))}
    </div>
  );
}

Uwaga: domyślne options = {} to nowy obiekt przy każdym renderze, więc efekt co render odtwarza obserwator. W produkcji przekaż stały obiekt.

Progresywne ładowanie obrazów

Znany efekt: rozmyty podgląd płynnie zmienia się w ostry obraz:

// Komponent z progresywnym ładowaniem (blur → sharp)
function ProgressiveImage({ src, placeholder, alt }) {
  const [imageLoaded, setImageLoaded] = useState(false);
  const { elementRef, hasIntersected } = useIntersectionObserver();

  return (
    <div ref={elementRef} className="progressive-image">
      {/* Rozmyty placeholder */}
      <img
        src={placeholder}
        alt={alt}
        className={`progressive-placeholder`}
        style={{
          filter: 'blur(10px)',
          transition: 'opacity 0.3s ease'
        }}
      />

      {/* Ostry obraz */}
      {hasIntersected && (
        <img
          src={src}
          alt={alt}
          onLoad={() => setImageLoaded(true)}
          className={`main-image ${imageLoaded ? 'visible' : 'hidden'}`}
          style={{
            opacity: imageLoaded ? 1 : 0,
            transition: 'opacity 0.3s ease'
          }}
        />
      )}
    </div>
  );
}

Lekki placeholder widać od razu, a pełny obraz wyłania się dopiero po zdarzeniu onLoad.

Lazy loading tras (Route-based)

React Router z Suspense

Najwięcej zyskasz, dzieląc kod według tras. Definiujesz komponent strony, owijasz go funkcją lazy z dynamicznym import() i dodajesz granicę Suspense z komponentem zastępczym (fallback):

import { Suspense, lazy } from 'react';
import { Routes, Route } from 'react-router';
import ErrorBoundary from './components/ErrorBoundary';
import LoadingSpinner from './components/LoadingSpinner';

// Lazy loading komponentów tras
const HomePage = lazy(() => import('./pages/HomePage'));
const ProductsPage = lazy(() => import('./pages/ProductsPage'));
const ProductDetailPage = lazy(() => import('./pages/ProductDetailPage'));
const UserProfilePage = lazy(() => import('./pages/UserProfilePage'));
const AdminPanel = lazy(() => import('./pages/AdminPanel'));

// Komponenty z custom loading i error handling
const LazyRoute = ({ children }) => (
  <ErrorBoundary>
    <Suspense fallback={<LoadingSpinner />}>
      {children}
    </Suspense>
  </ErrorBoundary>
);

function App() {
  return (
    <Routes>
      <Route
        path="/"
        element={
          <LazyRoute>
            <HomePage />
          </LazyRoute>
        }
      />
      <Route
        path="/products"
        element={
          <LazyRoute>
            <ProductsPage />
          </LazyRoute>
        }
      />
      <Route
        path="/products/:id"
        element={
          <LazyRoute>
            <ProductDetailPage />
          </LazyRoute>
        }
      />
      <Route
        path="/profile"
        element={
          <LazyRoute>
            <UserProfilePage />
          </LazyRoute>
        }
      />
      <Route
        path="/admin/*"
        element={
          <LazyRoute>
            <AdminPanel />
          </LazyRoute>
        }
      />
    </Routes>
  );
}

Dynamiczne import() zwraca Promise, który rozwiązuje się do modułu, a bundler wydziela każdą stronę do osobnego pliku. Bez Reacta to po prostu const module = await import('./module.js'). lazy wymaga eksportu domyślnego, a ErrorBoundary łapie nieudane pobranie.

Zaawansowane strategie ładowania tras

Trasę można pobrać, zanim użytkownik kliknie: po najechaniu na link, na podstawie przewidywanej ścieżki albo w czasie bezczynności:

// Preloading tras na podstawie user behavior
class RoutePreloader {
  constructor() {
    this.preloadedRoutes = new Set();
    this.setupPreloading();
  }

  setupPreloading() {
    // Preload na hover
    this.setupHoverPreloading();

    // Preload na podstawie prawdopodobieństwa
    this.setupPredictivePreloading();

    // Preload w idle time
    this.setupIdlePreloading();
  }

  setupHoverPreloading() {
    document.addEventListener('mouseover', (e) => {
      const link = e.target.closest('a[href]');
      if (link && this.shouldPreload(link.href)) {
        this.preloadRoute(new URL(link.href).pathname);
      }
    });
  }

  setupPredictivePreloading() {
    // Jeśli użytkownik jest na /products, preload /products/:id
    const currentPath = window.location.pathname;

    if (currentPath === '/products') {
      // Opóźnienie, żeby nie spowalniać ładowania bieżącej strony
      setTimeout(() => {
        this.preloadRoute('/products/:id');
      }, 2000);
    }
  }

  setupIdlePreloading() {
    if ('requestIdleCallback' in window) {
      requestIdleCallback(() => {
        this.preloadCriticalRoutes();
      });
    }
  }

  preloadRoute(path) {
    if (this.preloadedRoutes.has(path)) return;

    const routeMap = {
      '/products': () => import('./pages/ProductsPage'),
      '/products/:id': () => import('./pages/ProductDetailPage'),
      '/profile': () => import('./pages/UserProfilePage'),
      '/admin': () => import('./pages/AdminPanel')
    };

    const preloadFunction = routeMap[path];
    if (preloadFunction) {
      preloadFunction().then(() => {
        this.preloadedRoutes.add(path);
        console.log(`Route ${path} preloaded`);
      });
    }
  }

  shouldPreload(href) {
    // Preload tylko internal links
    return href.startsWith(window.location.origin);
  }

  preloadCriticalRoutes() {
    const critical = ['/products', '/profile'];
    critical.forEach(route => this.preloadRoute(route));
  }
}

// Inicjalizacja
new RoutePreloader();

requestIdleCallback czeka na bezczynność przeglądarki (kod sprawdza, czy funkcja istnieje).

Lazy loading komponentów

Lazy loading na poziomie komponentów

Ciężkie komponenty, jak wykresy czy edytor kodu, ładujemy dopiero po otwarciu zakładki, która ich potrzebuje:

// Lazy loading drogich komponentów
const ExpensiveChart = lazy(() => import('./components/ExpensiveChart'));
const DataVisualization = lazy(() => import('./components/DataVisualization'));
const VideoPlayer = lazy(() => import('./components/VideoPlayer'));
const CodeEditor = lazy(() => import('./components/CodeEditor'));

function Dashboard({ activeTab, data }) {
  return (
    <div className="dashboard">
      <nav className="dashboard-nav">
        {/* Nawigacja zawsze widoczna */}
      </nav>

      <main className="dashboard-content">
        {activeTab === 'charts' && (
          <Suspense fallback={<div>Ładowanie wykresów...</div>}>
            <ExpensiveChart data={data} />
          </Suspense>
        )}

        {activeTab === 'visualization' && (
          <Suspense fallback={<div>Ładowanie wizualizacji...</div>}>
            <DataVisualization data={data} />
          </Suspense>
        )}

        {activeTab === 'video' && (
          <Suspense fallback={<div>Ładowanie odtwarzacza...</div>}>
            <VideoPlayer />
          </Suspense>
        )}

        {activeTab === 'editor' && (
          <Suspense fallback={<div>Ładowanie edytora...</div>}>
            <CodeEditor />
          </Suspense>
        )}
      </main>
    </div>
  );
}

Nawigacja pojawia się od razu, a każda zakładka ma własny fallback.

Lazy loading modali i paneli bocznych

Modale otwiera tylko część użytkowników, więc hook useLazyModal importuje je dopiero po kliknięciu:

// Hook dla lazy modali
function useLazyModal() {
  const [isOpen, setIsOpen] = useState(false);
  const [Component, setComponent] = useState(null);

  const openModal = async (modalType) => {
    const modalMap = {
      'user-settings': () => import('./modals/UserSettingsModal'),
      'payment': () => import('./modals/PaymentModal'),
      'image-editor': () => import('./modals/ImageEditorModal'),
    };

    const importFunction = modalMap[modalType];
    if (importFunction) {
      const { default: ModalComponent } = await importFunction();
      setComponent(() => ModalComponent);
      setIsOpen(true);
    }
  };

  const closeModal = () => {
    setIsOpen(false);
    // Opcjonalnie: unload komponentu po zamknięciu
    setTimeout(() => setComponent(null), 300);
  };

  return { Component, isOpen, openModal, closeModal };
}

// Użycie lazy modali
function App() {
  const { Component: ModalComponent, isOpen, openModal, closeModal } = useLazyModal();

  return (
    <div>
      <button onClick={() => openModal('user-settings')}>
        Ustawienia użytkownika
      </button>
      <button onClick={() => openModal('payment')}>
        Płatność
      </button>
      <button onClick={() => openModal('image-editor')}>
        Edytor obrazów
      </button>

      {isOpen && ModalComponent && (
        <Suspense fallback={<div>Ładowanie...</div>}>
          <ModalComponent onClose={closeModal} />
        </Suspense>
      )}
    </div>
  );
}

Zapis setComponent(() => ModalComponent) jest konieczny, bo przekazaną wprost funkcję useState potraktowałby jak aktualizator stanu.

Lazy loading całych funkcjonalności

Całe moduły funkcjonalne, jak panel admina czy koszyk, ładujemy ze szkieletem (skeleton) zamiast spinnera:

// Lazy loading całych feature'ów
const AdminFeature = lazy(() => import('./features/Admin'));
const AnalyticsFeature = lazy(() => import('./features/Analytics'));
const ShoppingCartFeature = lazy(() => import('./features/ShoppingCart'));

function FeatureLoader({ feature, ...props }) {
  const featureMap = {
    admin: AdminFeature,
    analytics: AnalyticsFeature,
    cart: ShoppingCartFeature
  };

  const FeatureComponent = featureMap[feature];

  if (!FeatureComponent) {
    return <div>Nieznana funkcjonalność: {feature}</div>;
  }

  return (
    <ErrorBoundary>
      <Suspense fallback={<FeatureLoadingSkeleton feature={feature} />}>
        <FeatureComponent {...props} />
      </Suspense>
    </ErrorBoundary>
  );
}

// Skeleton dla różnych feature'ów
function FeatureLoadingSkeleton({ feature }) {
  const skeletons = {
    admin: <AdminSkeleton />,
    analytics: <ChartsSkeleton />,
    cart: <CartSkeleton />
  };

  return skeletons[feature] || <DefaultSkeleton />;
}

Skeleton pokazuje kształt przyszłej treści, więc strona mniej skacze.

Zaawansowane techniki lazy loading

Virtual scrolling z lazy loading

Virtual scrolling renderuje tylko widoczne wiersze długiej listy, tu z biblioteką react-window:

// Virtual scrolling dla dużych list
import { List } from 'react-window';

function VirtualizedList({ items, itemHeight = 50 }) {
  const [loadedItems, setLoadedItems] = useState(new Set());

  const loadItem = useCallback(async (index) => {
    if (loadedItems.has(index)) return;

    // Symulacja ładowania danych
    await new Promise(resolve => setTimeout(resolve, 100));
    setLoadedItems(prev => new Set([...prev, index]));
  }, [loadedItems]);

  const Row = ({ index, style }) => {
    const item = items[index];
    const isLoaded = loadedItems.has(index);

    useEffect(() => {
      if (!isLoaded) {
        loadItem(index);
      }
    }, [index, isLoaded, loadItem]);

    return (
      <div style={style} className="list-item">
        {isLoaded ? (
          <ItemContent item={item} />
        ) : (
          <ItemSkeleton />
        )}
      </div>
    );
  };

  return (
    <List
      style={{ height: 400 }}
      rowComponent={Row}
      rowCount={items.length}
      rowHeight={itemHeight}
      rowProps={{}}
      overscanCount={5} // 5 dodatkowych wierszy poza widokiem
    />
  );
}

overscanCount dorenderowuje kilka wierszy poza widokiem, żeby szybkie przewijanie nie odsłaniało pustki.

Lazy loading z cache

ComponentCache trzyma komponenty w mapie, a preload pobiera je z wyprzedzeniem:

// Cache dla lazy-loaded komponentów
class ComponentCache {
  constructor() {
    this.cache = new Map();
  }

  async get(key, loader) {
    if (this.cache.has(key)) {
      return this.cache.get(key);
    }

    const component = await loader();
    this.cache.set(key, component);
    return component;
  }

  preload(key, loader) {
    if (!this.cache.has(key)) {
      this.get(key, loader);
    }
  }

  clear(key) {
    if (key) {
      this.cache.delete(key);
    } else {
      this.cache.clear();
    }
  }
}

const componentCache = new ComponentCache();

// Hook wykorzystujący cache
function useLazyComponent(componentKey, loader) {
  const [Component, setComponent] = useState(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);

  const loadComponent = useCallback(async () => {
    if (Component) return;

    setLoading(true);
    setError(null);

    try {
      const loadedComponent = await componentCache.get(componentKey, loader);
      setComponent(() => loadedComponent.default);
    } catch (err) {
      setError(err);
    } finally {
      setLoading(false);
    }
  }, [componentKey, loader, Component]);

  // Preload funkcja
  const preload = useCallback(() => {
    componentCache.preload(componentKey, loader);
  }, [componentKey, loader]);

  return { Component, loading, error, loadComponent, preload };
}

Przeglądarka i tak nie wykona modułu dwa razy, ale własna mapa daje kontrolę: czyszczenie, statystyki albo czas ważności (TTL).

Lazy loading dopasowany do połączenia

Na wolnym łączu ładujemy mniej i w gorszej jakości. Network Information API podaje efektywny typ połączenia (effectiveType):

// Adaptacyjne ładowanie na podstawie połączenia
function useConnectionAwareLazyLoading() {
  const [connectionType, setConnectionType] = useState('4g');

  useEffect(() => {
    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;

    if (connection) {
      setConnectionType(connection.effectiveType);

      const updateConnection = () => {
        setConnectionType(connection.effectiveType);
      };

      connection.addEventListener('change', updateConnection);
      return () => connection.removeEventListener('change', updateConnection);
    }
  }, []);

  const shouldLazyLoad = useCallback((priority = 'normal') => {
    const strategies = {
      '4g': { immediate: true, normal: true, low: true },
      '3g': { immediate: true, normal: true, low: false },
      '2g': { immediate: true, normal: false, low: false },
      'slow-2g': { immediate: false, normal: false, low: false }
    };

    return strategies[connectionType]?.[priority] ?? false;
  }, [connectionType]);

  const getLoadingStrategy = useCallback(() => {
    const strategies = {
      '4g': 'aggressive', // Ładuj wszystko
      '3g': 'moderate',   // Ładuj tylko gdy potrzebne
      '2g': 'conservative', // Ładuj minimalnie
      'slow-2g': 'minimal' // Tylko niezbędne
    };

    return strategies[connectionType] || 'moderate';
  }, [connectionType]);

  return { connectionType, shouldLazyLoad, getLoadingStrategy };
}

// Komponent adaptujący się do połączenia
function AdaptiveImageGrid({ images }) {
  const { shouldLazyLoad, getLoadingStrategy } = useConnectionAwareLazyLoading();
  const strategy = getLoadingStrategy();

  const imageSettings = {
    aggressive: { quality: 'high', eager: 10 },
    moderate: { quality: 'medium', eager: 4 },
    conservative: { quality: 'low', eager: 2 },
    minimal: { quality: 'thumbnail', eager: 1 }
  };

  const settings = imageSettings[strategy];

  return (
    <div className="image-grid">
      {images.map((image, index) => (
        <AdaptiveImage
          key={image.id}
          src={image.url}
          quality={settings.quality}
          placeholder={image.placeholder}
          loading={index < settings.eager ? 'eager' : 'lazy'}
          shouldOptimize={strategy !== 'aggressive'}
        />
      ))}
    </div>
  );
}

To API działa tylko w przeglądarkach opartych na Chromium, dlatego hook startuje od wartości '4g' i sprawdza, czy navigator.connection istnieje.

Monitorowanie wydajności lazy loadingu

Optymalizacji nie ocenisz na oko. LazyLoadingMonitor mierzy czas ładowania, błędy i trafienia w cache:

// Monitoring wydajności lazy loading
class LazyLoadingMonitor {
  constructor() {
    this.metrics = {
      componentsLoaded: 0,
      totalLoadTime: 0,
      failedLoads: 0,
      cacheHits: 0
    };

    this.startTime = performance.now();
  }

  trackComponentLoad(componentName, loadTime, fromCache = false) {
    this.metrics.componentsLoaded++;
    this.metrics.totalLoadTime += loadTime;

    if (fromCache) {
      this.metrics.cacheHits++;
    }

    // Web Vitals tracking
    if (loadTime > 2500) { // Slow loading threshold
      console.warn(`Slow lazy load detected: ${componentName} took ${loadTime}ms`);
    }

    // Send to analytics
    this.sendMetrics('component_lazy_load', {
      component: componentName,
      loadTime,
      fromCache,
      timestamp: Date.now()
    });
  }

  trackFailedLoad(componentName, error) {
    this.metrics.failedLoads++;

    console.error(`Failed to lazy load ${componentName}:`, error);

    this.sendMetrics('component_lazy_load_error', {
      component: componentName,
      error: error.message,
      timestamp: Date.now()
    });
  }

  getAverageLoadTime() {
    return this.metrics.componentsLoaded > 0
      ? this.metrics.totalLoadTime / this.metrics.componentsLoaded
      : 0;
  }

  getCacheHitRate() {
    return this.metrics.componentsLoaded > 0
      ? (this.metrics.cacheHits / this.metrics.componentsLoaded) * 100
      : 0;
  }

  sendMetrics(event, data) {
    // Integracja z Google Analytics, Mixpanel, itp.
    if (typeof gtag !== 'undefined') {
      gtag('event', event, data);
    }
  }

  generateReport() {
    const sessionTime = performance.now() - this.startTime;

    return {
      sessionDuration: sessionTime,
      componentsLoaded: this.metrics.componentsLoaded,
      averageLoadTime: this.getAverageLoadTime(),
      cacheHitRate: this.getCacheHitRate(),
      failureRate: (this.metrics.failedLoads / Math.max(1, this.metrics.componentsLoaded + this.metrics.failedLoads)) * 100,
      totalFailures: this.metrics.failedLoads
    };
  }
}

// Singleton instance
const lazyLoadMonitor = new LazyLoadingMonitor();

// Hook z monitoringiem
function useMonitoredLazyComponent(componentName, loader) {
  const [Component, setComponent] = useState(null);
  const [loading, setLoading] = useState(false);

  const loadComponent = useCallback(async () => {
    if (Component) return;

    const startTime = performance.now();
    setLoading(true);

    try {
      const loadedComponent = await loader();
      const loadTime = performance.now() - startTime;

      setComponent(() => loadedComponent.default);
      lazyLoadMonitor.trackComponentLoad(componentName, loadTime);
    } catch (error) {
      lazyLoadMonitor.trackFailedLoad(componentName, error);
      throw error;
    } finally {
      setLoading(false);
    }
  }, [componentName, loader, Component]);

  return { Component, loading, loadComponent };
}

Próg 2500 ms to granica dobrego wyniku LCP.

Dobre praktyki lazy loadingu

1. Priorytyzacja treści

Najważniejsza zasada: to, co widać od razu, ładuj natychmiast, a resztę leniwie:

// Above-the-fold content - eager loading
// Below-the-fold content - lazy loading
function ContentStrategy() {
  return (
    <>
      {/* Critical path - eager */}
      <Header />
      <Hero />
      <MainContent />

      {/* Secondary content - lazy */}
      <Suspense fallback={<SectionSkeleton />}>
        <LazySection name="testimonials" />
      </Suspense>

      <Suspense fallback={<SectionSkeleton />}>
        <LazySection name="newsletter" />
      </Suspense>

      {/* Low priority - very lazy */}
      <Suspense fallback={<FooterSkeleton />}>
        <LazyFooter />
      </Suspense>
    </>
  );
}

Nagłówek i główna treść nie czekają, a opinie i stopka dochodzą w tle.

2. Łagodna obsługa błędów (graceful fallbacks)

Leniwe ładowanie może się nie udać, choćby po zerwaniu połączenia, więc łącz Suspense z granicą błędów:

// Zawsze zapewnij graceful fallbacks
function LazyComponentWrapper({ children, fallback, errorFallback }) {
  return (
    <ErrorBoundary
      fallback={errorFallback || <div>Wystąpił błąd podczas ładowania</div>}
    >
      <Suspense fallback={fallback || <LoadingSkeleton />}>
        {children}
      </Suspense>
    </ErrorBoundary>
  );
}

Zamiast pustego ekranu użytkownik widzi szkielet albo czytelny komunikat.

3. Preloading strategiczny

Na koniec przewidywanie: chwilę po wejściu na stronę pobieramy komponenty, które pewnie będą potrzebne:

// Strategiczne preloadowanie na podstawie user behavior
function useStrategicPreloading() {
  useEffect(() => {
    // Preload 2 sekundy po zamontowaniu komponentu
    const timeoutId = setTimeout(() => {
      // Preload prawdopodobnych następnych komponentów
      import('./components/UserProfile');
      import('./components/ShoppingCart');
    }, 2000);

    // Preload na podstawie mouse movement w kierunku linka
    const handleMouseMove = (e) => {
      // Jeśli kursor zbliża się do określonego elementu
      // preload związany komponent
    };

    document.addEventListener('mousemove', handleMouseMove);

    return () => {
      clearTimeout(timeoutId);
      document.removeEventListener('mousemove', handleMouseMove);
    };
  }, []);
}

Funkcja zwracana z useEffect usuwa timer i nasłuchiwanie, gdy komponent znika.

Podsumowanie

Lazy loading w skrócie:

  1. Zmniejsza początkowy rozmiar bundla - szybsze uruchamianie aplikacji
  2. Poprawia Web Vitals - szybsze FCP i LCP, o ile nie opóźniasz treści widocznej od razu
  3. Oszczędza zasoby - pamięć, transfer, bateria
  4. Skaluje z aplikacją - nowe funkcje nie powiększają startowego bundla
  5. Adaptuje się do warunków - ładowanie dopasowane do połączenia

Lazy loading powinien być niewidoczny dla użytkownika, a jednocześnie wyraźnie przyspieszać aplikację. To jedna z technik obok cache'owania, debouncingu (odkładania kosztownej operacji, aż użytkownik przestanie pisać) i virtual scrollingu. Zacznij od podziału według tras bo daje największy zysk najmniejszym kosztem. W kolejnej lekcji zmierzysz i odchudzisz sam bundle.

Pamiętaj: zwiedzający nie potrzebuje przy bramie map całej wyspy, tylko kolejnej mapy przy wejściu do nowego sektora.

W podglądzie poniżej przewiń galerię dinozaurów: karty ładują się dopiero wtedy, gdy wjadą w widok, a licznik pokazuje, ile kilobajtów pobrano do tej pory.

Kod do tej lekcji: lazy-loading-demo.html
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Lazy Loading - Park Jurajski</title>
    <style>
        body {
            font-family: 'Courier New', monospace;
            background: linear-gradient(135deg, #1e3c28 0%, #2d5a3d 100%);
            color: #e0e0e0;
            margin: 0;
            padding: 20px;
        }

        .header {
            text-align: center;
            padding: 20px;
            background: rgba(0, 0, 0, 0.3);
            border-radius: 10px;
            margin-bottom: 30px;
        }

        h1 {
            color: #4CAF50;
            text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5);
        }

        .gallery {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
            gap: 20px;
            max-width: 1200px;
            margin: 0 auto;
        }

        .dino-card {
            background: rgba(255, 255, 255, 0.1);
            border-radius: 10px;
            padding: 15px;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.3);
            transition: transform 0.3s ease;
        }

        .dino-card:hover {
            transform: translateY(-5px);
        }

        .dino-image {
            width: 100%;
            height: 200px;
            background: linear-gradient(45deg, #2d5a3d 0%, #3d6a4d 100%);
            border-radius: 8px;
            display: flex;
            align-items: center;
            justify-content: center;
            font-size: 60px;
            transition: opacity 0.5s ease;
            position: relative;
            overflow: hidden;
        }

        .dino-image.loading {
            opacity: 0.5;
        }

        .dino-image.loaded {
            opacity: 1;
            background: linear-gradient(45deg, #4CAF50 0%, #45a049 100%);
        }

        .dino-image::after {
            content: 'Ładowanie...';
            position: absolute;
            bottom: 10px;
            font-size: 12px;
            color: #fff;
            opacity: 0;
            transition: opacity 0.3s;
        }

        .dino-image.loading::after {
            opacity: 1;
        }

        .dino-info {
            margin-top: 10px;
        }

        .dino-name {
            font-size: 18px;
            font-weight: bold;
            color: #4CAF50;
            margin-bottom: 5px;
        }

        .dino-status {
            font-size: 14px;
            color: #aaa;
        }

        .stats {
            background: rgba(0, 0, 0, 0.3);
            padding: 20px;
            border-radius: 10px;
            margin: 30px auto;
            max-width: 600px;
            text-align: center;
        }

        .stat-item {
            display: inline-block;
            margin: 0 15px;
        }

        .stat-value {
            font-size: 24px;
            color: #4CAF50;
            font-weight: bold;
        }
    </style>
</head>
<body>
    <div class="header">
        <h1>System Lazy Loading - Park Jurajski</h1>
        <p>Obserwuj, jak dinozaury ładują się na żądanie!</p>
    </div>

    <div class="stats" id="stats">
        <div class="stat-item">
            <div class="stat-value" id="loaded-count">0</div>
            <div>Załadowane</div>
        </div>
        <div class="stat-item">
            <div class="stat-value" id="total-count">0</div>
            <div>Wszystkie</div>
        </div>
        <div class="stat-item">
            <div class="stat-value" id="bandwidth-saved">0 KB</div>
            <div>Pobrano</div>
        </div>
    </div>

    <div class="gallery" id="gallery"></div>

    <script>
        console.log('Inicjalizacja systemu Lazy Loading dla Parku Jurajskiego...');

        // Dane dinozaurów
        const dinosaurs = [
            { name: 'Tyrannosaurus Rex', emoji: '', species: 'T-Rex', size: 150 },
            { name: 'Velociraptor', emoji: '', species: 'Raptor', size: 80 },
            { name: 'Triceratops', emoji: '', species: 'Roślinożerca', size: 120 },
            { name: 'Brachiosaurus', emoji: '', species: 'Zauropod', size: 200 },
            { name: 'Stegosaurus', emoji: '', species: 'Roślinożerca', size: 110 },
            { name: 'Pteranodon', emoji: '', species: 'Latający', size: 90 },
            { name: 'Ankylosaurus', emoji: '', species: 'Opancerzony', size: 130 },
            { name: 'Spinosaurus', emoji: '', species: 'Mięsożerca', size: 170 },
            { name: 'Parasaurolophus', emoji: '', species: 'Hadrozaur', size: 100 },
            { name: 'Dilophosaurus', emoji: '', species: 'Mięsożerca', size: 95 }
        ];

        // Statystyki
        let loadedCount = 0;
        let totalBandwidthSaved = 0;

        // Klasa do obsługi lazy loading
        class DinosaurLazyLoader {
            constructor() {
                this.observer = new IntersectionObserver(
                    this.handleIntersection.bind(this),
                    {
                        root: null,
                        rootMargin: '100px',
                        threshold: 0.1
                    }
                );

                console.log('Intersection Observer utworzony');
            }

            handleIntersection(entries) {
                entries.forEach(entry => {
                    if (entry.isIntersecting) {
                        const card = entry.target;
                        this.loadDinosaur(card);
                        this.observer.unobserve(card);
                    }
                });
            }

            loadDinosaur(card) {
                const imageDiv = card.querySelector('.dino-image');
                const emoji = card.dataset.emoji;
                const size = parseInt(card.dataset.size);

                console.log(`Ładowanie dinozaura: ${card.dataset.name}`);

                // Symulacja opóźnienia ładowania
                setTimeout(() => {
                    imageDiv.textContent = emoji;
                    imageDiv.classList.remove('loading');
                    imageDiv.classList.add('loaded');

                    loadedCount++;
                    totalBandwidthSaved += size;

                    this.updateStats();

                    console.log(`Dinozaur załadowany: ${card.dataset.name}`);
                }, Math.random() * 500 + 200);
            }

            updateStats() {
                document.getElementById('loaded-count').textContent = loadedCount;
                document.getElementById('bandwidth-saved').textContent = totalBandwidthSaved + ' KB';
            }

            observe(element) {
                this.observer.observe(element);
            }
        }

        // Inicjalizacja
        const loader = new DinosaurLazyLoader();
        const gallery = document.getElementById('gallery');

        // Tworzenie kart dinozaurów
        dinosaurs.forEach((dino, index) => {
            const card = document.createElement('div');
            card.className = 'dino-card';
            card.dataset.name = dino.name;
            card.dataset.emoji = dino.emoji;
            card.dataset.size = dino.size;

            card.innerHTML = `
                <div class="dino-image loading"></div>
                <div class="dino-info">
                    <div class="dino-name">${dino.name}</div>
                    <div class="dino-status">Gatunek: ${dino.species} | ID: #${(index + 1).toString().padStart(3, '0')}</div>
                </div>
            `;

            gallery.appendChild(card);
            loader.observe(card);
        });

        // Aktualizacja statystyk
        document.getElementById('total-count').textContent = dinosaurs.length;

        console.log(`Utworzono ${dinosaurs.length} kart dinozaurów`);
        console.log('Przewiń stronę, aby obserwować lazy loading w akcji!');
        console.log('Dinozaury będą ładować się automatycznie gdy wejdą w viewport');
    </script>
</body>
</html>

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. Jaka jest główna korzyść z lazy loading komponentów?

  2. 2. Co zwraca wyrażenie dynamic import() w JavaScript?

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

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj etapy konfiguracji lazy loading komponentu:

  • Układanie w poziomie

    Ułóż elementy dynamic import w odpowiedniej kolejności:

  • Edytor kodu

    W pliku index.js jest klasa DinosaurAI z potrzebami (hunger, fatigue, danger w skali 0-100) i drzewem decyzji. Uzupełnij luki: ___BLANK1___ to dolna granica potrzeby, poniżej której updateNeed jej nie obniży, ___BLANK2___ to metoda tablicy, która przechodzi po nazwach potrzeb i zostawia tę o najwyższej wartości, a ___BLANK3___ to operator porównania w decide(): akcję potrzeby wybieramy tylko wtedy, gdy jej wartość jest większa niż 30. Zagrożenie powyżej 70 zawsze daje 'flee', a gdy żadna potrzeba nie przekracza 30, decide() zwraca 'idle'.

  • Klikanie w kolejności

    Ułóż elementy subskrypcji we wzorcu Observer:

  • Edytor kodu

    W pliku index.js jest klasa DataManager z cache w Map (z czasem życia TTL) i zapisem w localStorage. Uzupełnij luki: ___BLANK1___ to metoda JSON, która zamienia wartość na tekst przed zapisem w localStorage, ___BLANK2___ to operator porównania, przez który get() zwraca wartość z cache tylko przed upływem czasu expires, a ___BLANK3___ to metoda JSON, która zamienia tekst z localStorage z powrotem na wartość. Po wygaśnięciu wpisu get() czyta wartość z localStorage, dla brakującego klucza zwraca null, a invalidate usuwa klucz z obu miejsc.

  1. PytanieLazy loading
  2. Ułóż w kolejnościEtapy konfiguracji lazy loading komponentu
  3. PytanieDynamic import
  4. Ułóż w kolejnościSkładnia dynamic import w JavaScript
  5. PytanieOptymalizacja wydajności
  6. Zadanie z kodemĆwiczenie: AI dinozaura
  7. Kliknij w kolejnościKolejność: Wzorzec Observer subscribe
  8. Zadanie z kodemĆwiczenie: Menedżer danych

Przydatne artykuły