Kurs JavaScript i React · Moduł 6: React Router
Lazy loading komponentów w kosmicznej podróży
W tej lekcji8
Podczas długiej międzygalaktycznej podróży, nie potrzebujemy od razu ładować całego wyposażenia na statek kosmiczny. Podobnie w aplikacjach React, szczególnie tych większych, nie potrzebujemy ładować wszystkich komponentów od razu podczas inicjalizacji aplikacji. Oto gdzie przychodzi nam z pomocą leniwe ładowanie (lazy loading).
Czym jest Lazy Loading?
Lazy loading to technika optymalizacji wydajności, która polega na ładowaniu komponentów, modułów lub zasobów tylko wtedy, gdy są faktycznie potrzebne, zamiast ładować je z góry podczas inicjalizacji aplikacji. W React, realizujemy to za pomocą funkcji React.lazy() w połączeniu z Suspense.
Podstawy Lazy Loading w React
Aby zaimplementować lazy loading komponentu, zamiast standardowego importowania komponentu:
import HeavyDashboard from './HeavyDashboard';Używamy funkcji React.lazy() z dynamicznym importem:
import React, { lazy, Suspense } from 'react';
// Leniwe ładowanie komponentu
const HeavyDashboard = lazy(() => import('./HeavyDashboard'));
function App() {
return (
<div>
<h1>Centrum Kontroli Lotu</h1>
{/* Suspense zapewnia komponent zastępczy podczas ładowania */}
<Suspense fallback={<div>Ładowanie panelu sterowania...</div>}>
<HeavyDashboard />
</Suspense>
</div>
);
}W tym przykładzie:
lazy()przyjmuje funkcję, która musi wywołać dynamicznyimport()Suspensewyświetla fallback (komponent zastępczy) podczas ładowania leniwego komponentu- Faktyczny komponent
HeavyDashboardzaładuje się dopiero wtedy, gdy będzie renderowany
Lazy Loading w React Router
W aplikacjach wykorzystujących React Router, możemy leniwie ładować komponenty dla poszczególnych tras. Dzięki temu początkowy bundle aplikacji będzie mniejszy, a użytkownik będzie pobierać kod tylko dla tych części aplikacji, które odwiedza:
import React, { lazy, Suspense } from 'react';
import { BrowserRouter as Router, Routes, Route } from 'react-router-dom';
// Komponenty ładowane leniwie
const MissionControl = lazy(() => import('./MissionControl'));
const SpaceshipSettings = lazy(() => import('./SpaceshipSettings'));
const GalacticMap = lazy(() => import('./GalacticMap'));
const CrewQuarters = lazy(() => import('./CrewQuarters'));
// Komponent ładowany zawsze (mały i często używany)
import NavigationBar from './NavigationBar';
function App() {
return (
<Router>
<NavigationBar />
<Suspense fallback={<div className="loading-screen">Przygotowanie modułu...</div>}>
<Routes>
<Route path="/" element={<HomePage />} />
<Route path="/mission-control" element={<MissionControl />} />
<Route path="/spaceship-settings" element={<SpaceshipSettings />} />
<Route path="/galactic-map" element={<GalacticMap />} />
<Route path="/crew-quarters" element={<CrewQuarters />} />
</Routes>
</Suspense>
</Router>
);
}W tym przykładzie tylko komponenty dla aktualnie odwiedzanej trasy będą ładowane. Możemy również dodać indywidualne komponenty Suspense dla każdej trasy, jeśli chcemy różne wskaźniki ładowania:
<Routes>
<Route path="/" element={<HomePage />} />
<Route
path="/mission-control"
element={
<Suspense fallback={<div>Inicjalizacja panelu kontroli misji...</div>}>
<MissionControl />
</Suspense>
}
/>
<Route
path="/galactic-map"
element={
<Suspense fallback={<div>Ładowanie mapy galaktycznej...</div>}>
<GalacticMap />
</Suspense>
}
/>
</Routes>Zaawansowane techniki Lazy Loading
Prefetching (wstępne ładowanie)
Czasami wiemy z dużym prawdopodobieństwem, że użytkownik odwiedzi określoną trasę. Możemy wtedy wstępnie załadować komponent, zanim użytkownik faktycznie kliknie w link:
import { lazy } from 'react';
// Deklaracja leniwego komponentu
const GalacticMap = lazy(() => import('./GalacticMap'));
// Komponent nawigacyjny z prefetchingiem
function NavigationLink({ to, children }) {
// Funkcja do wstępnego ładowania
const prefetchComponent = () => {
// Dynamiczny import jako Promise - rozpoczyna ładowanie
import('./GalacticMap');
};
return (
<Link
to={to}
onMouseOver={prefetchComponent} // Rozpocznij ładowanie po najechaniu myszą
onFocus={prefetchComponent} // Dla dostępności, ładowanie po fokusie
>
{children}
</Link>
);
}
// Użycie w komponencie
function Navigation() {
return (
<nav>
<NavigationLink to="/galactic-map">Mapa Galaktyczna</NavigationLink>
</nav>
);
}Grupowanie tras (route-based code splitting)
Możemy grupować powiązane ze sobą lazy-loaded komponenty, aby zmniejszyć liczbę oddzielnych żądań sieciowych:
// Grupowanie komponentów związanych z kokpitem
const CockpitModule = lazy(() => import('./modules/CockpitModule'));
// Używanie zgrupowanego modułu w routingu
<Route path="/cockpit/*" element={<CockpitModule />} />
// W CockpitModule.js mamy wewnętrzne route'y
function CockpitModule() {
return (
<Routes>
<Route path="/" element={<CockpitOverview />} />
<Route path="/navigation" element={<NavigationControls />} />
<Route path="/engines" element={<EngineControls />} />
<Route path="/life-support" element={<LifeSupportSystems />} />
</Routes>
);
}W tym podejściu, wszystkie komponenty kokpitu zostaną pobrane jako jeden chunk kodu, gdy użytkownik wejdzie na dowolną trasę /cockpit/*.
Obsługa błędów ładowania
W kosmosie zawsze musimy być przygotowani na nieprzewidziane sytuacje. W przypadku lazy loadingu, może się zdarzyć, że próba ładowania komponentu się nie powiedzie (np. z powodu problemów z siecią):
import React, { lazy, Suspense } from 'react';
import { ErrorBoundary } from 'react-error-boundary';
const GalacticMap = lazy(() => import('./GalacticMap'));
function ErrorFallback({ error, resetErrorBoundary }) {
return (
<div className="error-container">
<h2>Napotkano problem podczas ładowania modułu</h2>
<p>Błąd: {error.message}</p>
<button onClick={resetErrorBoundary}>
Spróbuj ponownie
</button>
</div>
);
}
function MapSection() {
return (
<ErrorBoundary
FallbackComponent={ErrorFallback}
onReset={() => {
// Opcjonalna logika resetowania stanu
}}
>
<Suspense fallback={<div>Ładowanie mapy galaktycznej...</div>}>
<GalacticMap />
</Suspense>
</ErrorBoundary>
);
}Kiedy warto używać Lazy Loading?
Lazy loading jest szczególnie przydatny w następujących przypadkach:
Duże aplikacje z wieloma komponentami, gdzie użytkownik zazwyczaj korzysta tylko z niewielkiej części funkcjonalności podczas jednej sesji
Rzadko używane funkcje - na przykład, panel administratora, który jest używany tylko przez kilku użytkowników
Ciężkie zależności - komponenty, które wykorzystują duże biblioteki (np. edytory tekstu, mapy, wykresy)
Alternatywne ścieżki użytkownika - gdy różni użytkownicy korzystają z różnych części aplikacji w zależności od ich roli
Najlepsze praktyki
1. Umieść Suspense wyżej w drzewie komponentów
Zamiast owijać każdy lazy-loaded komponent w osobny Suspense, często lepiej jest umieścić jeden Suspense wyżej w drzewie:
function App() {
return (
<Suspense fallback={<GlobalLoadingSpinner />}>
<Router>
<Routes>
{/* Lazy-loaded routes */}
</Routes>
</Router>
</Suspense>
);
}2. Stosuj odpowiednie granice podziału kodu (code splitting boundaries)
Dziel kod wzdłuż naturalnych granic aplikacji:
- Podział według tras (routingu)
- Podział według modułów funkcjonalnych
- Podział między częścią publiczną i prywatną aplikacji
3. Unikaj zbyt drobnego podziału
Zbyt drobny podział kodu może prowadzić do wielu małych żądań sieciowych, co może być mniej wydajne niż kilka większych. Znajdź złoty środek.
4. Zawsze dostarczaj dobry fallback
Upewnij się, że fallback w Suspense jest wizualnie spójny z resztą aplikacji i daje użytkownikowi wyraźną informację o stanie ładowania.
5. Testuj na rzeczywistych urządzeniach i wolnych połączeniach
Lazy loading może działać świetnie na szybkich połączeniach developerskich, ale zawsze testuj jak wygląda doświadczenie użytkownika na wolniejszych połączeniach.
Przykładowa implementacja
Oto przykład bardziej rozbudowanej aplikacji kosmicznej z lazy loadingiem:
import React, { lazy, Suspense } from 'react';
import { BrowserRouter as Router, Routes, Route, Navigate } from 'react-router-dom';
import { ErrorBoundary } from 'react-error-boundary';
// Komponenty ładowane zawsze
import MainLayout from './layouts/MainLayout';
import LoadingScreen from './components/LoadingScreen';
import ErrorFallback from './components/ErrorFallback';
// Lazy-loaded pages
const HomePage = lazy(() => import('./pages/HomePage'));
const Dashboard = lazy(() => import('./pages/Dashboard'));
const NavigationModule = lazy(() => import('./modules/NavigationModule'));
const LifeSupportModule = lazy(() => import('./modules/LifeSupportModule'));
const CommunicationModule = lazy(() => import('./modules/CommunicationModule'));
const CrewModule = lazy(() => import('./modules/CrewModule'));
const SettingsPage = lazy(() => import('./pages/SettingsPage'));
const NotFoundPage = lazy(() => import('./pages/NotFoundPage'));
function App() {
return (
<Router>
<ErrorBoundary FallbackComponent={ErrorFallback}>
<MainLayout>
<Suspense fallback={<LoadingScreen />}>
<Routes>
<Route path="/" element={<HomePage />} />
<Route path="/dashboard" element={<Dashboard />} />
{/* Zagnieżdżone moduły z własnymi trasami */}
<Route path="/navigation/*" element={<NavigationModule />} />
<Route path="/life-support/*" element={<LifeSupportModule />} />
<Route path="/communication/*" element={<CommunicationModule />} />
<Route path="/crew/*" element={<CrewModule />} />
<Route path="/settings" element={<SettingsPage />} />
<Route path="/404" element={<NotFoundPage />} />
<Route path="*" element={<Navigate to="/404" replace />} />
</Routes>
</Suspense>
</MainLayout>
</ErrorBoundary>
</Router>
);
}
export default App;Podsumowanie
Lazy loading to potężna technika optymalizacji React aplikacji, która pozwala:
- Zmniejszyć początkowy rozmiar paczki JavaScript (bundle)
- Skrócić czas ładowania aplikacji
- Poprawić doświadczenie użytkownika poprzez szybsze wstępne renderowanie
- Ładować kod tylko wtedy, gdy jest faktycznie potrzebny
Jest to jak inteligentne zarządzanie zasobami na statku kosmicznym - zamiast zabierać wszystko na początku podróży, transportujemy tylko to, co jest aktualnie potrzebne, oszczędzając paliwo i przyspieszając start.
Kod do tej lekcji: App.jsx
import React from 'react';
import { BrowserRouter, Routes, Route, Link, useSearchParams } from 'react-router-dom';
// Lista produktów z filtrowaniem
function ProductList() {
const [searchParams, setSearchParams] = useSearchParams();
const category = searchParams.get('category') || 'all';
const sortBy = searchParams.get('sort') || 'name';
const search = searchParams.get('search') || '';
const products = [
{ id: 1, name: 'Skafander kosmiczny', category: 'equipment', price: 5000 },
{ id: 2, name: 'Hełm astronauty', category: 'equipment', price: 1500 },
{ id: 3, name: 'Rakieta modelowa', category: 'toys', price: 200 },
{ id: 4, name: 'Teleskop', category: 'tools', price: 3000 },
{ id: 5, name: 'Mapa galaktyki', category: 'tools', price: 500 },
{ id: 6, name: 'Figurka astronauty', category: 'toys', price: 50 },
];
// Filtrowanie
let filteredProducts = products;
if (category !== 'all') {
filteredProducts = filteredProducts.filter(p => p.category === category);
}
if (search) {
filteredProducts = filteredProducts.filter(p =>
p.name.toLowerCase().includes(search.toLowerCase())
);
}
// Sortowanie
filteredProducts.sort((a, b) => {
if (sortBy === 'price') return a.price - b.price;
return a.name.localeCompare(b.name);
});
const updateFilter = (key, value) => {
const newParams = new URLSearchParams(searchParams);
if (value) {
newParams.set(key, value);
} else {
newParams.delete(key);
}
setSearchParams(newParams);
};
return (
<div className="product-list">
<h1>Sklep kosmiczny</h1>
<div className="filters">
<div className="filter-group">
<label>Szukaj:</label>
<input
type="text"
value={search}
onChange={(e) => updateFilter('search', e.target.value)}
placeholder="Wpisz nazwę..."
/>
</div>
<div className="filter-group">
<label>Kategoria:</label>
<select
value={category}
onChange={(e) => updateFilter('category', e.target.value)}
>
<option value="all">Wszystkie</option>
<option value="equipment">Sprzęt</option>
<option value="tools">Narzędzia</option>
<option value="toys">Zabawki</option>
</select>
</div>
<div className="filter-group">
<label>Sortuj:</label>
<select
value={sortBy}
onChange={(e) => updateFilter('sort', e.target.value)}
>
<option value="name">Nazwa</option>
<option value="price">Cena</option>
</select>
</div>
</div>
<div className="current-params">
<strong>URL params:</strong> {searchParams.toString() || '(brak)'}
</div>
<div className="products">
{filteredProducts.map(product => (
<div key={product.id} className="product">
<h3>{product.name}</h3>
<p className="category">{product.category}</p>
<p className="price">{product.price} zł</p>
</div>
))}
{filteredProducts.length === 0 && (
<p className="no-results">Brak produktów spełniających kryteria</p>
)}
</div>
</div>
);
}
function App() {
return (
<BrowserRouter>
<div className="app">
<nav>
<Link to="/products">Wszystkie</Link>
<Link to="/products?category=equipment">Sprzęt</Link>
<Link to="/products?category=tools">Narzędzia</Link>
<Link to="/products?category=toys&sort=price">Zabawki (cena)</Link>
</nav>
<Routes>
<Route path="/" element={<ProductList />} />
<Route path="/products" element={<ProductList />} />
</Routes>
</div>
</BrowserRouter>
);
}
export default App;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 zwraca funkcja React.lazy() w React?
2. Jaka jest rola komponentu Suspense przy lazy loadingu?
Zadania praktyczne w grze
- Edytor kodu
Protected Routes
- Klikanie w kolejności
Ułóż składnię Route z dynamicznym parametrem:
- Edytor kodu
Lazy loading komponentów
- Układanie w pionie
Uporządkuj kroki lazy loadingu komponentu w React: