Kurs JavaScript i React · Moduł 8: Zaawansowane wzorce React
Concurrent Mode i Suspense
W tej lekcji9
Wyobraź sobie centrum kontroli misji na stacji kosmicznej, gdzie jednocześnie przetwarzane są setki sygnałów z różnych czujników. Niektóre dane są pilne (alarmy), inne mniej (statystyki pogodowe z odległych planet). React Concurrent Mode działa na podobnej zasadzie - pozwala priorytetyzować aktualizacje interfejsu, aby aplikacja pozostała responsywna nawet podczas ciężkich operacji.
Czym jest Concurrent Mode?
Concurrent Mode (tryb współbieżny) to zestaw mechanizmów w React, które pozwalają na przerywanie i wznawianie renderowania. Tradycyjnie React renderował synchronicznie - gdy zaczynał aktualizację, musiał ją dokończyć, zanim mógł zareagować na cokolwiek innego. W trybie współbieżnym React może:
- Rozpocząć renderowanie aktualizacji
- Przerwać je, gdy pojawi się pilniejsza aktualizacja
- Wrócić do przerwanej pracy później
To jak kosmiczny kontroler, który może odłożyć analizę danych z dalekiej sondy, gdy nagle pojawi się alert o zbliżającej się asteroidzie.
startTransition - priorytetyzacja aktualizacji
startTransition to API, które mówi Reactowi: "ta aktualizacja nie jest pilna, możesz ją przerwać". Jest idealne dla operacji, które mogą chwilę poczekać, jak filtrowanie dużej listy czy nawigacja między zakładkami.
import { useState, startTransition } from 'react';
function GalaxySearch() {
const [searchInput, setSearchInput] = useState('');
const [searchResults, setSearchResults] = useState([]);
const handleSearch = (value) => {
// Aktualizacja inputa jest PILNA - użytkownik musi widzieć co pisze
setSearchInput(value);
// Filtrowanie wyników jest MNIEJ PILNE
startTransition(() => {
const filtered = galaxyDatabase.filter(
galaxy => galaxy.name.toLowerCase().includes(value.toLowerCase())
);
setSearchResults(filtered);
});
};
return (
<div>
<input
value={searchInput}
onChange={(e) => handleSearch(e.target.value)}
placeholder="Szukaj galaktyk..."
/>
<GalaxyList results={searchResults} />
</div>
);
}Dzięki startTransition input reaguje natychmiast na wpisywanie, nawet jeśli filtrowanie tysięcy galaktyk zajmuje chwilę.
useTransition - śledzenie stanu przejścia
useTransition to hook, który oprócz startTransition daje nam flagę isPending, informującą, czy przejście jest w toku:
import { useState, useTransition } from 'react';
function MissionDashboard() {
const [activeTab, setActiveTab] = useState('overview');
const [isPending, startTransition] = useTransition();
const switchTab = (tab) => {
startTransition(() => {
setActiveTab(tab);
});
};
return (
<div>
<nav>
{['overview', 'crew', 'systems', 'navigation'].map(tab => (
<button
key={tab}
onClick={() => switchTab(tab)}
style={{
opacity: isPending && activeTab !== tab ? 0.7 : 1,
fontWeight: activeTab === tab ? 'bold' : 'normal',
}}
>
{tab.toUpperCase()}
</button>
))}
</nav>
{isPending && <div className="loading-bar">Ładowanie panelu...</div>}
<TabContent tab={activeTab} />
</div>
);
}Suspense - deklaratywne oczekiwanie na dane
Suspense to komponent, który pozwala "zawiesić" renderowanie, dopóki dane nie będą gotowe. Zamiast ręcznie zarządzać stanami ładowania, deklarujesz co pokazać podczas oczekiwania:
import { Suspense } from 'react';
function SpaceStation() {
return (
<div>
<h1>Stacja Kosmiczna Alpha</h1>
<Suspense fallback={<LoadingSpinner message="Ładowanie danych załogi..." />}>
<CrewList />
</Suspense>
<Suspense fallback={<LoadingSpinner message="Sprawdzanie systemów..." />}>
<SystemsStatus />
</Suspense>
</div>
);
}Każda sekcja ładuje się niezależnie - użytkownik widzi dane załogi, gdy tylko będą gotowe, nie czekając na status systemów.
Suspense z lazy loading
Najczęstsze zastosowanie Suspense to ładowanie komponentów dynamicznie za pomocą React.lazy:
import { lazy, Suspense } from 'react';
// Komponenty ładowane dynamicznie
const StarMap = lazy(() => import('./StarMap'));
const MissionLog = lazy(() => import('./MissionLog'));
const CrewManagement = lazy(() => import('./CrewManagement'));
function CommandCenter() {
const [view, setView] = useState('map');
return (
<div>
<nav>
<button onClick={() => setView('map')}>Mapa gwiazd</button>
<button onClick={() => setView('log')}>Dziennik misji</button>
<button onClick={() => setView('crew')}>Załoga</button>
</nav>
<Suspense fallback={<div>Ładowanie modułu...</div>}>
{view === 'map' && <StarMap />}
{view === 'log' && <MissionLog />}
{view === 'crew' && <CrewManagement />}
</Suspense>
</div>
);
}Zagnieżdżone Suspense
Możemy zagnieżdżać komponenty Suspense, tworząc hierarchię ładowania. Zewnętrzny Suspense łapie wszystko, wewnętrzne pozwalają na bardziej granularną kontrolę:
function MissionControl() {
return (
<Suspense fallback={<FullPageLoader />}>
<header>
<MissionTitle />
</header>
<main>
<Suspense fallback={<SectionLoader text="Mapa..." />}>
<InteractiveStarMap />
</Suspense>
<aside>
<Suspense fallback={<SectionLoader text="Statystyki..." />}>
<MissionStats />
</Suspense>
<Suspense fallback={<SectionLoader text="Komunikaty..." />}>
<CommunicationLog />
</Suspense>
</aside>
</main>
</Suspense>
);
}useDeferredValue - opóźnione wartości
useDeferredValue to hook, który pozwala opóźnić aktualizację wartości. React najpierw wyrenderuje z poprzednią wartością (pilna aktualizacja), a potem z nową (mniej pilna):
import { useState, useDeferredValue, useMemo } from 'react';
function PlanetExplorer() {
const [filter, setFilter] = useState('');
const deferredFilter = useDeferredValue(filter);
// Lista renderuje się z opóźnioną wartością filtra
const filteredPlanets = useMemo(() => {
return allPlanets.filter(p =>
p.name.toLowerCase().includes(deferredFilter.toLowerCase())
);
}, [deferredFilter]);
const isStale = filter !== deferredFilter;
return (
<div>
<input
value={filter}
onChange={(e) => setFilter(e.target.value)}
placeholder="Filtruj planety..."
/>
<div style={{ opacity: isStale ? 0.6 : 1 }}>
{filteredPlanets.map(planet => (
<PlanetCard key={planet.id} planet={planet} />
))}
</div>
</div>
);
}Kiedy używać poszczególnych API?
| API | Zastosowanie | Przykład |
|---|---|---|
startTransition | Aktualizacje, które mogą poczekać | Zmiana filtrów, nawigacja między zakładkami |
useTransition | Jak wyżej + wskaźnik ładowania | Przełączanie widoków z loading state |
Suspense | Oczekiwanie na dane lub kod | Lazy loading, pobieranie danych |
useDeferredValue | Opóźnienie renderowania wartości | Filtrowanie dużych list, wyszukiwanie |
Podsumowanie
Concurrent Mode i Suspense to jak zaawansowany system zarządzania priorytetami na stacji kosmicznej. Zamiast przetwarzać wszystkie sygnały sekwencyjnie (blokując ważne alerty na czas analizy mniej istotnych danych), React może inteligentnie priorytetyzować aktualizacje:
- startTransition pozwala oznaczyć mniej pilne aktualizacje
- useTransition dodatkowo informuje o stanie przejścia
- Suspense deklaratywnie zarządza oczekiwaniem na dane
- useDeferredValue opóźnia kosztowne renderowania
Te mechanizmy współpracują ze sobą, tworząc responsywne interfejsy nawet w złożonych aplikacjach z dużą ilością danych i ciężkimi operacjami.
Kod do tej lekcji: App.jsx
import React, { useState, useTransition, useDeferredValue, Suspense, lazy, useMemo } from 'react';
// ============================================
// DEMO: Concurrent Mode i Suspense
// ============================================
// Symulacja wolnego API
function fetchGalaxies(filter) {
return new Promise(resolve => {
setTimeout(() => {
const allGalaxies = [
'Droga Mleczna', 'Andromeda', 'Trójkąt', 'Sombrero',
'Wir', 'Czarne Oko', 'Centaurus A', 'Cygnus A',
'Wielki Obłok Magellana', 'Mały Obłok Magellana',
'NGC 1300', 'NGC 4414', 'Messier 87', 'Pinwheel',
'Cartwheel', 'Hoag', 'Sunflower', 'Tadpole',
];
const filtered = allGalaxies.filter(g =>
g.toLowerCase().includes(filter.toLowerCase())
);
resolve(filtered);
}, 800);
});
}
// --- SEKCJA 1: startTransition i useTransition ---
function GalaxySearch() {
const [searchInput, setSearchInput] = useState('');
const [searchResults, setSearchResults] = useState([]);
const [isPending, startTransition] = useTransition();
const handleSearch = async (value) => {
setSearchInput(value);
startTransition(async () => {
const results = await fetchGalaxies(value);
setSearchResults(results);
});
};
return (
<section style={sectionStyle}>
<h2 style={headingStyle}>useTransition - Wyszukiwanie galaktyk</h2>
<p style={{ fontSize: '13px', opacity: 0.7, marginBottom: '12px' }}>
Wpisz nazwę galaktyki. Input reaguje natychmiast, lista aktualizuje się z opóźnieniem.
</p>
<input
value={searchInput}
onChange={(e) => handleSearch(e.target.value)}
placeholder="Szukaj galaktyk..."
style={inputStyle}
/>
<div style={{ opacity: isPending ? 0.5 : 1, transition: 'opacity 0.3s' }}>
{isPending && <p style={{ color: '#ffd700' }}>Przeszukiwanie kosmosu...</p>}
{searchResults.length > 0 ? (
<ul style={{ listStyle: 'none', padding: 0 }}>
{searchResults.map((galaxy, i) => (
<li key={i} style={listItemStyle}>{galaxy}</li>
))}
</ul>
) : (
!isPending && searchInput && <p style={{ opacity: 0.5 }}>Brak wyników</p>
)}
</div>
</section>
);
}
// --- SEKCJA 2: useDeferredValue ---
function HeavyPlanetList({ filter }) {
const planets = useMemo(() => {
const allPlanets = [];
for (let i = 1; i <= 200; i++) {
allPlanets.push(`Planeta-${String(i).padStart(3, '0')}`);
}
return allPlanets.filter(p =>
p.toLowerCase().includes(filter.toLowerCase())
);
}, [filter]);
return (
<ul style={{ listStyle: 'none', padding: 0, maxHeight: '200px', overflowY: 'auto' }}>
{planets.map((planet, i) => (
<li key={i} style={listItemStyle}>{planet}</li>
))}
</ul>
);
}
function DeferredValueDemo() {
const [filter, setFilter] = useState('');
const deferredFilter = useDeferredValue(filter);
const isStale = filter !== deferredFilter;
return (
<section style={sectionStyle}>
<h2 style={headingStyle}>useDeferredValue - Filtrowanie planet</h2>
<p style={{ fontSize: '13px', opacity: 0.7, marginBottom: '12px' }}>
Lista renderuje się z opóźnioną wartością filtra.
</p>
<input
value={filter}
onChange={(e) => setFilter(e.target.value)}
placeholder="Filtruj planety..."
style={inputStyle}
/>
<div style={{ opacity: isStale ? 0.5 : 1, transition: 'opacity 0.3s' }}>
<HeavyPlanetList filter={deferredFilter} />
</div>
</section>
);
}
// --- SEKCJA 3: Suspense z lazy loading ---
const StarMap = lazy(() => new Promise(resolve => {
setTimeout(() => {
resolve({
default: () => (
<div style={{ padding: '20px', background: '#0d1b2a', borderRadius: '8px' }}>
<h3 style={{ color: '#00d4ff' }}>Mapa gwiazd</h3>
<p>Wyświetlanie 1,247 systemów gwiezdnych w sektorze Alpha...</p>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(4, 1fr)', gap: '8px', marginTop: '12px' }}>
{['Sirius', 'Vega', 'Altair', 'Rigel', 'Betelgeuse', 'Polaris', 'Deneb', 'Capella'].map(star => (
<div key={star} style={{ padding: '8px', background: '#1a2a3a', borderRadius: '4px', textAlign: 'center', fontSize: '12px' }}>
{star}
</div>
))}
</div>
</div>
)
});
}, 1500);
}));
const MissionLog = lazy(() => new Promise(resolve => {
setTimeout(() => {
resolve({
default: () => (
<div style={{ padding: '20px', background: '#0d1b2a', borderRadius: '8px' }}>
<h3 style={{ color: '#ffd700' }}>Dziennik misji</h3>
{['Misja Alpha rozpoczęta', 'Osiągnięto orbitę Marsa', 'Sonda wysłana na Europę', 'Kontakt z bazą utracony', 'Systemy przywrócone'].map((log, i) => (
<p key={i} style={{ fontSize: '13px', padding: '4px 0', borderBottom: '1px solid #1a2a3a' }}>
[{5 - i}h temu] {log}
</p>
))}
</div>
)
});
}, 2000);
}));
function SuspenseDemo() {
const [view, setView] = useState('none');
return (
<section style={sectionStyle}>
<h2 style={headingStyle}>Suspense - Lazy loading</h2>
<p style={{ fontSize: '13px', opacity: 0.7, marginBottom: '12px' }}>
Komponenty ładowane dynamicznie z Suspense fallback.
</p>
<div style={{ display: 'flex', gap: '8px', marginBottom: '12px' }}>
<button onClick={() => setView('map')} style={view === 'map' ? btnActiveStyle : btnStyle}>
Mapa gwiazd
</button>
<button onClick={() => setView('log')} style={view === 'log' ? btnActiveStyle : btnStyle}>
Dziennik misji
</button>
</div>
<Suspense fallback={
<div style={{ padding: '20px', textAlign: 'center', color: '#ffd700' }}>
Ładowanie modułu...
</div>
}>
{view === 'map' && <StarMap />}
{view === 'log' && <MissionLog />}
</Suspense>
</section>
);
}
// --- SEKCJA 4: Tabs z useTransition ---
function TabsDemo() {
const [activeTab, setActiveTab] = useState('overview');
const [isPending, startTransition] = useTransition();
const tabs = [
{ id: 'overview', label: 'Przegląd', content: 'Status misji: Aktywna. Wszystkie systemy nominalne.' },
{ id: 'crew', label: 'Załoga', content: 'Załoga: 6 członków. Kapitan Ra, 2 pilotów, 2 inżynierów, 1 naukowiec.' },
{ id: 'systems', label: 'Systemy', content: 'Silniki: 85%. Tlen: 97%. Tarcze: 100%. Komunikacja: Aktywna.' },
];
const switchTab = (tabId) => {
startTransition(() => {
setActiveTab(tabId);
});
};
const activeContent = tabs.find(t => t.id === activeTab);
return (
<section style={sectionStyle}>
<h2 style={headingStyle}>useTransition - Zakładki</h2>
<div style={{ display: 'flex', gap: '4px', marginBottom: '12px' }}>
{tabs.map(tab => (
<button
key={tab.id}
onClick={() => switchTab(tab.id)}
style={{
...btnStyle,
background: activeTab === tab.id ? '#00d4ff' : '#1a2a3a',
color: activeTab === tab.id ? '#000' : '#fff',
opacity: isPending ? 0.7 : 1,
}}
>
{tab.label}
</button>
))}
</div>
<div style={{ padding: '12px', background: '#0d1b2a', borderRadius: '6px' }}>
{isPending ? (
<p style={{ color: '#ffd700' }}>Przełączanie...</p>
) : (
<p>{activeContent?.content}</p>
)}
</div>
</section>
);
}
// --- Style ---
const sectionStyle = {
marginBottom: '24px',
padding: '16px',
background: 'rgba(255,255,255,0.03)',
borderRadius: '12px',
border: '1px solid rgba(255,255,255,0.08)',
};
const headingStyle = { color: '#00d4ff', marginBottom: '8px', fontSize: '16px' };
const inputStyle = {
width: '100%',
padding: '10px',
background: '#0d1b2a',
border: '1px solid #1a3a5c',
borderRadius: '6px',
color: '#fff',
fontSize: '14px',
marginBottom: '12px',
boxSizing: 'border-box',
};
const listItemStyle = {
padding: '6px 10px',
background: '#0d1b2a',
marginBottom: '4px',
borderRadius: '4px',
fontSize: '13px',
};
const btnStyle = {
padding: '8px 14px',
background: '#1a2a3a',
border: 'none',
borderRadius: '6px',
color: '#fff',
cursor: 'pointer',
fontSize: '13px',
};
const btnActiveStyle = {
...btnStyle,
background: '#00d4ff',
color: '#000',
};
// --- App ---
function App() {
return (
<div style={{ padding: '20px', background: '#0a0e1a', color: '#e0e0e0', minHeight: '100vh', fontFamily: 'system-ui' }}>
<h1 style={{ color: '#ffd700', textAlign: 'center', marginBottom: '24px' }}>
Concurrent Mode i Suspense
</h1>
<GalaxySearch />
<DeferredValueDemo />
<SuspenseDemo />
<TabsDemo />
</div>
);
}
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. Kiedy warto użyć Higher-Order Component (HOC) zamiast custom hooka?
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż składnię użycia startTransition do oznaczenia mniej pilnej aktualizacji:
- Edytor kodu
System Compound Components
- Układanie w pionie
Uporządkuj etapy tworzenia własnego custom hooka w React:
- Edytor kodu
State machine z Context API