Kurs JavaScript i React · Moduł 9: Nowoczesne hooki React
Wirtualizacja list i windowing
W tej lekcji7
Wyobraź sobie, że patrzysz przez okno obserwacyjne statku kosmicznego na miliardy gwiazd w galaktyce. Nie widzisz wszystkich naraz - widzisz tylko te, które są w twoim polu widzenia. Właśnie na tym polega wirtualizacja list w React: zamiast renderować tysiące elementów DOM, renderujemy tylko te, które są aktualnie widoczne na ekranie.
Problem: renderowanie tysięcy elementów
Gdy mamy listę z tysiącami elementów (np. lista planet, logi z serwera, wiadomości czatu), renderowanie ich wszystkich jednocześnie może spowodować poważne problemy z wydajnością:
// PROBLEM: Renderowanie 10 000 elementów na raz
function SlowStarCatalog({ stars }) {
// To stworzy 10 000 elementów DOM na raz!
return (
<div style={{ height: '600px', overflow: 'auto' }}>
{stars.map(star => (
<div key={star.id} style={{
padding: '12px',
borderBottom: '1px solid #333',
backgroundColor: '#0a0a1a',
color: '#ccc'
}}>
<strong style={{ color: '#ffd700' }}>{star.name}</strong>
<span style={{ marginLeft: '10px' }}>Typ: {star.type}</span>
<span style={{ marginLeft: '10px' }}>Odległość: {star.distance} ly</span>
</div>
))}
</div>
);
}
// Każdy z 10 000 elementów:
// - tworzy węzły DOM
// - zajmuje pamięć przeglądarki
// - spowalnia początkowe renderowanie
// - spowalnia scrollowanieEfekty takiego podejścia to:
- Długi czas początkowego renderowania - przeglądarka musi stworzyć tysiące elementów DOM
- Wysokie zużycie pamięci - każdy element DOM zajmuje pamięć
- Lagujące scrollowanie - przeglądarka musi obsługiwać ogromne drzewo DOM
- Zamrażanie interfejsu - użytkownik czeka na odpowiedź aplikacji
Koncept windowing
Windowing (okienkowanie) to technika, która renderuje tylko elementy widoczne w "oknie" (viewport) kontenera scroll. Reszta elementów po prostu nie istnieje w DOM - są dodawane dopiero, gdy użytkownik przewija listę.
// KONCEPT: Jak działa windowing
// Wyobraź sobie listę 10 000 elementów, każdy o wysokości 50px
// Kontener ma wysokość 500px - widzimy tylko 10 elementów naraz
// BEZ windowing:
// DOM zawiera: 10 000 elementów = 500 000px wysokości
// Pamięć: ogromna
// Z windowing:
// DOM zawiera: ~15 elementów (10 widocznych + bufor)
// "Pusta" przestrzeń symulowana przez padding/transform
// Pamięć: minimalna
// Schemat działania:
// [padding-top: symuluje elementy powyżej]
// [element 45] <- widoczny
// [element 46] <- widoczny
// [element 47] <- widoczny
// [element 48] <- widoczny
// ...
// [element 54] <- widoczny
// [padding-bottom: symuluje elementy poniżej]Schemat pokazuje zasadę, ale za wirtualizacją nie stoi magia, tylko trochę arytmetyki. Zanim sięgniesz po bibliotekę, zbuduj takie okno sam.
Okno zbudowane ręcznie
Potrzebujesz stanu z pozycją przewinięcia i trzech obliczeń. Pierwszy widoczny wiersz to liczba przewiniętych pikseli podzielona przez wysokość wiersza, a do widocznych wierszy dokładasz kilka zapasowych (overscan) nad i pod oknem, żeby przy szybkim przewijaniu nie mignęła pustka:
function getVisibleRange(scrollTop, { rowHeight, viewHeight, count, overscan = 3 }) {
const first = Math.floor(scrollTop / rowHeight);
const visible = Math.ceil(viewHeight / rowHeight);
const start = Math.max(0, first - overscan);
const end = Math.min(count, first + visible + overscan);
return { start, end };
}Funkcja nie wie nic o Reakcie: dla okna 400 px, wierszy po 40 px i przewinięcia o 4000 px zwraca zakres od 97 do 113. Komponent trzyma scrollTop w stanie i renderuje tylko ten wycinek tablicy:
function StarWindow({ stars }) {
const [scrollTop, setScrollTop] = useState(0);
const { start, end } = getVisibleRange(scrollTop, { rowHeight: 40, viewHeight: 400, count: stars.length });
return (
<div style={{ height: 400, overflowY: 'auto' }} onScroll={(e) => setScrollTop(e.currentTarget.scrollTop)}>
<div style={{ height: stars.length * 40, position: 'relative' }}>
{stars.slice(start, end).map((star, i) => (
<div key={star.id} style={{ position: 'absolute', top: (start + i) * 40, height: 40 }}>
{star.name}
</div>
))}
</div>
</div>
);
}Wewnętrzny div ma wysokość całej listy, więc suwak zachowuje się tak, jakby wszystkie gwiazdy były w DOM. Każdy wiersz dostaje top równy swojemu indeksowi w pełnej liście razy wysokość wiersza, a slice(start, end) nie zmienia tablicy stars, tylko zwraca jej fragment. Tak samo działa VirtualizedList w edytorze obok, a react-window robi to samo, dokładając zmienne wysokości, siatki i atrybuty dostępności.
react-window - biblioteka do wirtualizacji
react-window to lekka biblioteka autorstwa Briana Vaughna (autora oryginalnego react-virtualized), która implementuje windowing w sposób prosty i wydajny.
Ważne: w 2025 roku wyszła wersja 2 i jej API jest zupełnie inne niż w wersji 1. Komponenty FixedSizeList i VariableSizeList zniknęły, a ich miejsce zajął jeden komponent List (do siatek służy Grid). Jeśli instalujesz bibliotekę dziś, dostaniesz wersję 2.x, więc poniżej uczymy nowego API, a stare pokazujemy na końcu sekcji dla projektów, które wciąż są na 1.x.
List - elementy o stałej wysokości
Komponent List przyjmuje kilka kluczowych propsów. rowComponent to komponent rysujący jeden wiersz, rowCount to liczba wszystkich elementów, rowHeight to wysokość wiersza w pikselach, a rowProps to obiekt z dodatkowymi danymi, które biblioteka przekaże do każdego wiersza. Sam wiersz dostaje index, style oraz ariaAttributes (atrybuty dostępności, takie jak role="listitem"):
import { List } from 'react-window';
// Generujemy 10 000 gwiazd
const stars = Array.from({ length: 10000 }, (_, index) => ({
id: index,
name: `Gwiazda-${index + 1}`,
type: ['Karzeł biały', 'Olbrzym czerwony', 'Gwiazda neutronowa', 'Supernowa'][index % 4],
magnitude: (Math.random() * 20 - 5).toFixed(2)
}));
// Komponent pojedynczego wiersza
// Dostaje index, style, ariaAttributes + wszystko z rowProps
function StarRow({ index, style, ariaAttributes, stars }) {
const star = stars[index];
return (
<div {...ariaAttributes} style={{
...style,
display: 'flex',
alignItems: 'center',
padding: '0 16px',
borderBottom: '1px solid #1a1a3e',
backgroundColor: index % 2 === 0 ? '#0a0a1a' : '#0f0f2a',
color: '#ccc'
}}>
<span style={{ flex: 1, color: '#ffd700' }}>{star.name}</span>
<span style={{ flex: 1 }}>{star.type}</span>
<span style={{ width: '100px', textAlign: 'right' }}>
mag: {star.magnitude}
</span>
</div>
);
}
function VirtualizedStarCatalog() {
return (
<div style={{ padding: '20px', backgroundColor: '#0f0f23' }}>
<h2 style={{ color: '#00d2ff' }}>Katalog Gwiazd (10 000 obiektów)</h2>
<List
rowComponent={StarRow} // Komponent wiersza
rowCount={stars.length} // Liczba elementów
rowHeight={50} // Wysokość każdego elementu (stała!)
rowProps={{ stars }} // Dane przekazywane do każdego wiersza
style={{ height: 400 }} // Wysokość kontenera
/>
</div>
);
}Dwie rzeczy są tu obowiązkowe. Po pierwsze, style z propsów musisz przekazać do elementu wiersza, bo zawiera pozycję absolutną i przesunięcie transform, dzięki którym wiersz trafia we właściwe miejsce. Po drugie, List wypełnia wysokość określoną w style albo wysokość rodzica, więc kontener musi ją mieć. Szerokość domyślnie wynosi 100%. W teście z 10 000 gwiazd i kontenerem 400px biblioteka wyrenderowała zaledwie 11 wierszy: 8 widocznych plus kilka zapasowych (overscanCount).
Stała liczba w rowHeight to najwydajniejsza opcja, ponieważ biblioteka nie musi mierzyć wysokości elementów - zna ją z góry. Używaj jej zawsze, gdy elementy listy mają stałą, znaną wysokość.
rowHeight jako funkcja - elementy o różnej wysokości
Gdy elementy listy mają różne wysokości (np. wiadomości czatu, posty), w wersji 1 sięgało się po VariableSizeList. W wersji 2 zostajemy przy List, a do rowHeight przekazujemy funkcję. Biblioteka wywoła ją z indeksem wiersza i obiektem rowProps:
import { List } from 'react-window';
const messages = Array.from({ length: 5000 }, (_, i) => ({
id: i,
sender: ['Kapitan Nova', 'Inżynier Rex', 'Nawigator Luna'][i % 3],
text: i % 5 === 0
? 'Dłuższa wiadomość z raportem misji - status systemów napędowych, komunikacji i podtrzymywania życia. Wszystkie parametry w normie.'
: 'Krótka wiadomość #' + (i + 1)
}));
// Funkcja zwracająca wysokość elementu na podstawie indeksu
const getRowHeight = (index, { messages }) => {
const message = messages[index];
// Dłuższa wiadomość = wyższa komórka
return message.text.length > 50 ? 80 : 50;
};
function MessageRow({ index, style, ariaAttributes, messages }) {
const msg = messages[index];
return (
<div {...ariaAttributes} style={{
...style,
padding: '8px 16px',
borderBottom: '1px solid #1a1a3e',
backgroundColor: '#0a0a1a',
}}>
<strong style={{ color: '#e94560' }}>{msg.sender}:</strong>
<p style={{ color: '#ccc', margin: '4px 0 0 0', fontSize: '14px' }}>
{msg.text}
</p>
</div>
);
}
function VirtualizedChat() {
return (
<List
rowComponent={MessageRow}
rowCount={messages.length}
rowHeight={getRowHeight}
rowProps={{ messages }}
style={{ height: 400 }}
/>
);
}Wiersz wiadomości wygląda tak samo jak wcześniej, zmieniło się tylko źródło wysokości. Jeśli wysokości nie da się wyliczyć z góry, bo zależą od zawijania tekstu, wersja 2 ma hook useDynamicRowHeight, który mierzy wiersze po wyrenderowaniu. Dokumentacja ostrzega jednak, że to mniej wydajne niż znane z góry wartości, więc zawsze, gdy się da, podawaj liczbę lub funkcję.
Starsze API (react-window 1.x)
Jeśli pracujesz w projekcie, który ma w package.json wersję 1.x, zobaczysz tam zapis z osobnymi komponentami. Zamiast rowComponent wiersz trafia jako children, liczbę elementów podaje itemCount, wysokość itemSize, a wymiary kontenera propsy height i width. Oba przykłady z tej lekcji wyglądały w wersji 1 tak:
// react-window 1.x - API usunięte w wersji 2
import { FixedSizeList, VariableSizeList } from 'react-window';
<FixedSizeList
height={400} // Wysokość kontenera
width="100%" // Szerokość kontenera
itemCount={stars.length} // Liczba elementów
itemSize={50} // Wysokość każdego elementu (stała!)
>
{StarRow}
</FixedSizeList>;
<VariableSizeList
height={400}
width="100%"
itemCount={messages.length}
itemSize={getItemSize} // (index) => wysokość
>
{MessageRow}
</VariableSizeList>W wersji 1 wiersz dostawał tylko index i style, a dane czytał z zewnętrznej zmiennej (albo z propa itemData). Przy aktualizacji do wersji 2 zamieniasz komponenty na List, itemCount na rowCount, itemSize na rowHeight i przenosisz dane do rowProps.
Kiedy używać wirtualizacji vs paginacji?
Wybór między wirtualizacją a paginacją zależy od kontekstu - tak jak wybór między teleskopem a mapą gwiazd:
Wirtualizacja jest lepsza gdy:
- Użytkownik potrzebuje płynnego scrollowania (np. feed, czat, logi)
- Dane są już załadowane (lub ładowane strumieniowo)
- Zachowanie "naturalnego" scrollbara jest ważne
- Lista jest bardzo długa, ale elementy są proste
Paginacja jest lepsza gdy:
- Dane są ładowane z serwera stronicami
- Użytkownik chce przeskakiwać do konkretnych stron
- SEO jest ważne (każda strona ma osobny URL)
- Elementy listy są bardzo złożone
Porównajmy oba podejścia w kodzie. Paginacja trzyma w stanie numer strony i wycina z tablicy tylko jej fragment, a wirtualizacja oddaje całą tablicę do List:
// Paginacja - klasyczne podejście
function PaginatedList({ items, pageSize }) {
const [page, setPage] = useState(1);
const totalPages = Math.ceil(items.length / pageSize);
return (
<div>
{/* Renderuj tylko elementy aktualnej strony */}
{items.slice((page - 1) * pageSize, page * pageSize).map(item => (
<ItemCard key={item.id} item={item} />
))}
<div>
<button disabled={page === 1} onClick={() => setPage(p => p - 1)}>
Poprzednia
</button>
<span>Strona {page} z {totalPages}</span>
<button disabled={page === totalPages} onClick={() => setPage(p => p + 1)}>
Następna
</button>
</div>
</div>
);
}
// Wirtualizacja - nowoczesne podejście dla długich list
function ItemRow({ index, style, items }) {
return (
<div style={style}>
<ItemCard item={items[index]} />
</div>
);
}
function VirtualizedList({ items }) {
return (
<List
rowComponent={ItemRow}
rowCount={items.length}
rowHeight={60}
rowProps={{ items }}
style={{ height: 600 }}
/>
);
}W obu wersjach w DOM jest tylko garść kart, różni się sposób poruszania po danych: przyciski stron kontra płynne przewijanie. W wersji 2 nie przekazujesz już funkcji jako children, wiersz zawsze jest osobnym komponentem w rowComponent.
Mierzenie poprawy wydajności
Aby udowodnić, że wirtualizacja działa, możemy zmierzyć różnicę w wydajności. Komponent przełącza się między zwykłą listą a List i loguje przybliżony czas do następnej klatki:
function NameRow({ index, style, items }) {
return <div style={style}>{items[index].name}</div>;
}
function PerformanceComparison() {
const [mode, setMode] = useState('virtualized');
const items = useMemo(
() => Array.from({ length: 10000 }, (_, i) => ({ id: i, name: `Item ${i}` })),
[]
);
// Mierzymy czas renderowania
useEffect(() => {
const start = performance.now();
// Po renderze
requestAnimationFrame(() => {
const end = performance.now();
console.log(`Czas renderowania (${mode}): ${(end - start).toFixed(2)}ms`);
});
}, [mode]);
return (
<div>
<div>
<button onClick={() => setMode('normal')}>Normalna lista</button>
<button onClick={() => setMode('virtualized')}>Zwirtualizowana</button>
</div>
{mode === 'normal' ? (
// 10 000 elementów DOM
<div style={{ height: 400, overflow: 'auto' }}>
{items.map(item => <div key={item.id}>{item.name}</div>)}
</div>
) : (
// ~15 elementów DOM
<List
rowComponent={NameRow}
rowCount={items.length}
rowHeight={35}
rowProps={{ items }}
style={{ height: 400 }}
/>
)}
</div>
);
}
// Wyniki zależą od urządzenia i przeglądarki - zmierz je u siebie.
// Normalna lista: czas i pamięć rosną z liczbą elementów
// Zwirtualizowana: praca zależy od wysokości okna, nie od długości listyNie podajemy tu konkretnych milisekund, bo na laptopie i na starym telefonie wyniki różnią się wielokrotnie. Dokładniejszy obraz da Ci zakładka Profiler w React DevTools i panel Performance w przeglądarce.
Skrzynka narzędzi wydajności: powtórka przed zadaniami
Wirtualizacja to tylko jedno z narzędzi wydajności. Część pozostałych, jak Profiler czy podział kodu, poznałeś w module o zaawansowanych wzorcach, a zadania po kolejnych lekcjach wracają do całej skrzynki. Zbierzmy ją więc w jednym miejscu: od tego, jak React renderuje, po pracę w tle, poza głównym wątkiem.
Jak React renderuje
Każda aktualizacja przechodzi przez ten sam cykl. Najpierw coś wyzwala render, np. zmiana stanu przez setState. W fazie renderu React wywołuje komponenty i dostaje nowy JSX, a podczas uzgadniania (reconciliation) porównuje nowe drzewo z poprzednim. W fazie commit nanosi na DOM tylko różnice, przeglądarka maluje ekran, a na końcu React uruchamia efekty z useEffect. Od React 18 kilka aktualizacji stanu trafia do jednego renderu (automatic batching) nie tylko w obsłudze zdarzeń, ale też w setTimeout, w obietnicach i w natywnych zdarzeniach:
setTimeout(() => {
setFuel((fuel) => fuel - 10);
setSpeed((speed) => speed + 1);
// React 18+: jeden render zamiast dwóch
}, 1000);Wcześniej każda z tych dwóch zmian dawała osobny render. Współbieżne renderowanie (concurrent rendering) idzie krok dalej: React może przygotowywać kilka wersji interfejsu naraz i przerywać mniej pilne rendery, a korzystają z tego useTransition i useDeferredValue z tego modułu.
Profiler: mierz, zanim zoptymalizujesz
Komponent Profiler mierzy, jak długo renderuje się fragment drzewa. Owijasz nim mierzony komponent, a React wywołuje onRender po każdym renderze tego fragmentu:
import { Profiler } from 'react';
function onRender(id, phase, actualDuration) {
console.log(id + ' [' + phase + ']: ' + actualDuration.toFixed(1) + ' ms');
}
<Profiler id="StarMap" onRender={onRender}>
<StarMap />
</Profiler>Argument phase ma wartość "mount" przy pierwszym renderze i "update" przy kolejnych, a actualDuration to czas renderu w milisekundach. Te same dane pokaże zakładka Profiler w React DevTools: otwierasz DevTools, przechodzisz do zakładki Profiler, klikasz Start profiling, wykonujesz interakcję, zatrzymujesz nagrywanie i czytasz flamegraph, w którym od razu widać komponenty renderujące się najdłużej. Dopiero wtedy wybierasz technikę: memo, wirtualizację albo podział kodu.
Podział kodu i rozmiar paczki
Bundler, np. Vite albo webpack, buduje paczkę w kilku etapach. Analizuje kod i graf zależności, usuwa nieużywane eksporty (tree shaking), dzieli kod na mniejsze części (code splitting) i minifikuje je, a na końcu serwer kompresuje pliki przez gzip albo brotli. Tree shaking działa tylko z modułami ES, bo import i export są statyczne:
import { debounce } from 'lodash-es'; // do paczki trafia tylko debounce
const _ = require('lodash'); // CommonJS: trafia cała bibliotekaCiężki widok wydzielasz do osobnej części przez lazy i dynamiczny import(). Jego kod pobiera się dopiero przy pierwszym renderze, a Suspense pokazuje w tym czasie fallback:
const StarMap = lazy(() => import('./StarMap'));
<Suspense fallback={<p>Ładowanie mapy...</p>}>
<StarMap />
</Suspense>Które moduły wydzielić, podpowie analizator paczki, np. rollup-plugin-visualizer w Vite albo webpack-bundle-analyzer. Pokazuje rozmiar każdego modułu po kompresji, więc łatwo znaleźć te, które przekraczają przyjęty budżet.
Obrazy ładowane leniwie
Pełnowymiarowe zdjęcia też nie muszą przychodzić od razu. Atrybut loading="lazy" każe przeglądarce pobrać obraz dopiero wtedy, gdy zbliża się on do ekranu. Do tego mała, rozmyta miniatura na czas ładowania i zdarzenia onLoad oraz onError, które przełączają stan komponentu:
<img
src={planet.full}
alt={planet.name}
loading="lazy"
onLoad={() => setStatus('loaded')}
onError={() => setStatus('error')}
/>Gdy potrzebujesz własnej logiki, np. animacji przy wejściu w ekran, tę samą obserwację zrobisz przez IntersectionObserver.
Pomiary w przeglądarce
PerformanceObserver nasłuchuje wpisów z Performance API, np. własnych pomiarów (measure) i danych o ładowaniu strony (navigation):
const observer = new PerformanceObserver((list) => {
list.getEntries().forEach((entry) => console.log('Performance:', entry));
});
observer.observe({ entryTypes: ['measure', 'navigation'] });Wskaźniki Core Web Vitals (LCP, INP, CLS) najprościej zbierzesz biblioteką web-vitals.
Praca w tle: Web Worker i Service Worker
Ciężkich obliczeń nie musisz robić w wątku, który rysuje interfejs. Web Worker to osobny wątek, z którym rozmawiasz wiadomościami: postMessage wysyła dane, onmessage odbiera wynik w event.data, a terminate zatrzymuje wątek. W komponencie tworzysz go w efekcie i zatrzymujesz w sprzątaniu:
useEffect(() => {
const worker = new Worker(new URL('./route.worker.js', import.meta.url), { type: 'module' });
worker.onmessage = (event) => setResult(event.data);
workerRef.current = worker;
return () => worker.terminate();
}, []);Kliknięcie wysyła dane przez workerRef.current.postMessage(...), a interfejs reaguje dalej, bo liczy inny wątek. Wątki robocze omówimy szerzej w następnym module. Service Worker z kolei stoi między aplikacją a siecią i w zdarzeniu fetch decyduje, skąd wziąć odpowiedź. Pliki statyczne obsługuje się zwykle strategią cache-first:
async function cacheFirst(request, cache) {
const cached = await cache.match(request);
if (cached) return cached;
const response = await fetch(request);
await cache.put(request, response.clone());
return response;
}Dane z API dostają strategię network-first, która działa odwrotnie: najpierw pyta sieć i zapisuje świeżą kopię przez cache.put, a do cache.match sięga dopiero wtedy, gdy sieci nie ma. Kopia przez response.clone() jest potrzebna, bo treść odpowiedzi da się przeczytać tylko raz.
Podsumowanie
Wirtualizacja list to jedna z najskuteczniejszych technik optymalizacji wydajności w React:
- Renderuj tylko widoczne elementy - użyj
react-windowlubreact-virtuoso Listz liczbą wrowHeightdla elementów o stałej wysokości (najwydajniejsze; w 1.xFixedSizeList)Listz funkcją wrowHeightdla elementów o zmiennej wysokości (w 1.xVariableSizeList), auseDynamicRowHeight, gdy wysokości trzeba zmierzyć- Mierz przed i po - używaj React DevTools Profiler i
performance.now() - Rozważ paginację jako alternatywę, gdy dane są ładowane z serwera
Tak jak teleskop na statku kosmicznym pokazuje nam tylko fragment nieba w danym momencie, wirtualizacja pokazuje użytkownikowi tylko fragment listy - ale z płynnością godną najlepszych systemów nawigacyjnych.
Kod do tej lekcji: App.jsx
import React, { useState, useRef, useCallback, useEffect } from 'react';
// Generowanie dużego zbioru danych - 10 000 obiektów gwiezdnych
function generateStarCatalog(count) {
const types = ['Gwiazda', 'Mgławica', 'Galaktyka', 'Pulsar', 'Kwazar'];
const constellations = ['Orion', 'Andromeda', 'Cassiopeia', 'Lyra', 'Cygnus', 'Draco'];
const catalog = [];
for (let i = 0; i < count; i++) {
catalog.push({
id: i,
name: `${types[i % types.length]}-${(i + 1).toString().padStart(5, '0')}`,
type: types[i % types.length],
constellation: constellations[i % constellations.length],
magnitude: (Math.random() * 15 - 2).toFixed(2),
distance: (Math.random() * 100000).toFixed(0),
});
}
return catalog;
}
// Wersja BEZ wirtualizacji - renderuje WSZYSTKIE elementy
function NaiveList({ items, itemHeight }) {
return (
<div style={{
height: '300px', overflow: 'auto',
border: '1px solid #ff4444', borderRadius: '8px',
}}>
{items.map(item => (
<div key={item.id} style={{
height: itemHeight, padding: '0 12px',
display: 'flex', alignItems: 'center', gap: '12px',
borderBottom: '1px solid #1a2a3c',
background: item.id % 2 === 0 ? 'rgba(255,255,255,0.02)' : 'transparent',
fontSize: '13px', color: '#c0c8d0',
}}>
<span style={{ color: '#00d4ff', width: '180px' }}>{item.name}</span>
<span style={{ color: '#778da9', width: '100px' }}>{item.constellation}</span>
<span style={{ color: '#ffd700', width: '60px' }}>{item.magnitude}m</span>
<span style={{ color: '#556677' }}>{Number(item.distance).toLocaleString()} ly</span>
</div>
))}
</div>
);
}
// Wersja Z wirtualizacją - renderuje TYLKO widoczne elementy
function VirtualizedList({ items, itemHeight, containerHeight }) {
const containerRef = useRef(null);
const [scrollTop, setScrollTop] = useState(0);
// Obliczamy które elementy są widoczne
const totalHeight = items.length * itemHeight;
const startIndex = Math.floor(scrollTop / itemHeight);
const visibleCount = Math.ceil(containerHeight / itemHeight);
// Dodajemy bufor - kilka elementów więcej z góry i z dołu
const overscan = 5;
const renderStart = Math.max(0, startIndex - overscan);
const renderEnd = Math.min(items.length, startIndex + visibleCount + overscan);
const visibleItems = items.slice(renderStart, renderEnd);
const offsetY = renderStart * itemHeight;
const handleScroll = useCallback((e) => {
setScrollTop(e.target.scrollTop);
}, []);
return (
<div
ref={containerRef}
onScroll={handleScroll}
style={{
height: containerHeight, overflow: 'auto',
border: '1px solid #4ecdc4', borderRadius: '8px',
position: 'relative',
}}
>
{/* Pusty kontener o pełnej wysokości - dla scrollbara */}
<div style={{ height: totalHeight, position: 'relative' }}>
{/* Przesunięta grupa widocznych elementów */}
<div style={{
position: 'absolute', top: offsetY, left: 0, right: 0,
}}>
{visibleItems.map(item => (
<div key={item.id} style={{
height: itemHeight, padding: '0 12px',
display: 'flex', alignItems: 'center', gap: '12px',
borderBottom: '1px solid #1a2a3c',
background: item.id % 2 === 0 ? 'rgba(255,255,255,0.02)' : 'transparent',
fontSize: '13px', color: '#c0c8d0',
}}>
<span style={{ color: '#00d4ff', width: '180px' }}>{item.name}</span>
<span style={{ color: '#778da9', width: '100px' }}>{item.constellation}</span>
<span style={{ color: '#ffd700', width: '60px' }}>{item.magnitude}m</span>
<span style={{ color: '#556677' }}>{Number(item.distance).toLocaleString()} ly</span>
</div>
))}
</div>
</div>
</div>
);
}
// Wirtualizowana siatka: ta sama zasada co w liście, tylko w każdym wierszu stoją 3 elementy
function VirtualizedGrid({ items, containerHeight }) {
const [scrollTop, setScrollTop] = useState(0);
const COLUMNS = 3;
const ROW_HEIGHT = 70;
const overscan = 2;
const rowCount = Math.ceil(items.length / COLUMNS);
const firstRow = Math.floor(scrollTop / ROW_HEIGHT);
const visibleRows = Math.ceil(containerHeight / ROW_HEIGHT);
const startRow = Math.max(0, firstRow - overscan);
const endRow = Math.min(rowCount, firstRow + visibleRows + overscan);
// Do DOM trafiają tylko elementy z widocznych wierszy
const visibleItems = items.slice(startRow * COLUMNS, endRow * COLUMNS);
return (
<div
onScroll={(e) => setScrollTop(e.currentTarget.scrollTop)}
style={{
height: containerHeight, overflow: 'auto',
border: '1px solid #ffd700', borderRadius: '8px',
}}
>
<div style={{ height: rowCount * ROW_HEIGHT, position: 'relative' }}>
{visibleItems.map((item, i) => {
const index = startRow * COLUMNS + i;
const row = Math.floor(index / COLUMNS);
const column = index % COLUMNS;
return (
<div key={item.id} style={{
position: 'absolute', top: row * ROW_HEIGHT,
left: `${(column * 100) / COLUMNS}%`, width: `${100 / COLUMNS}%`,
height: ROW_HEIGHT, padding: '6px', boxSizing: 'border-box',
}}>
<div style={{
height: '100%', borderRadius: '6px', padding: '8px',
background: 'rgba(255, 215, 0, 0.06)', fontSize: '12px',
}}>
<div style={{ color: '#00d4ff' }}>{item.name}</div>
<div style={{ color: '#778da9' }}>{item.constellation}, {item.magnitude}m</div>
</div>
</div>
);
})}
</div>
</div>
);
}
export default function App() {
const [data] = useState(() => generateStarCatalog(10000));
const [mode, setMode] = useState('virtual');
const ITEM_HEIGHT = 40;
const CONTAINER_HEIGHT = 300;
// Mierzymy czas renderowania
const [renderTime, setRenderTime] = useState(null);
useEffect(() => {
const start = performance.now();
requestAnimationFrame(() => {
setRenderTime((performance.now() - start).toFixed(1));
});
}, [mode]);
return (
<div style={{
minHeight: '100vh',
background: 'linear-gradient(135deg, #0a0e27 0%, #1a1a3e 100%)',
padding: '24px', fontFamily: 'monospace', color: '#e0e1dd',
}}>
<h1 style={{ color: '#00d4ff', textAlign: 'center', marginBottom: '4px' }}>
Wirtualizacja list
</h1>
<p style={{ color: '#778da9', textAlign: 'center', marginBottom: '20px', fontSize: '13px' }}>
Renderuj tysiące elementów bez spadku wydajności
</p>
<div style={{ maxWidth: '750px', margin: '0 auto' }}>
<div style={{ display: 'flex', gap: '8px', marginBottom: '16px', justifyContent: 'center' }}>
{['naive', 'virtual', 'grid'].map(m => (
<button
key={m}
onClick={() => setMode(m)}
style={{
padding: '8px 16px',
background: mode === m ? '#1a3a5c' : 'transparent',
border: `1px solid ${mode === m ? '#00d4ff' : '#1a3a5c'}`,
borderRadius: '6px',
color: mode === m ? '#00d4ff' : '#778da9',
cursor: 'pointer', fontSize: '13px',
}}
>
{m === 'naive' ? 'Bez wirtualizacji' : m === 'virtual' ? 'Wirtualizowana lista' : 'Wirtualizowana siatka'}
</button>
))}
</div>
<div style={{
padding: '10px 16px', marginBottom: '12px',
background: 'rgba(0, 212, 255, 0.08)', borderRadius: '8px',
display: 'flex', justifyContent: 'space-between', fontSize: '13px',
}}>
<span>Elementów: <strong style={{ color: '#ffd700' }}>{data.length.toLocaleString()}</strong></span>
<span>Renderowanych DOM: <strong style={{ color: mode === 'naive' ? '#ff4444' : '#4ecdc4' }}>
{mode === 'naive' ? data.length.toLocaleString() : mode === 'virtual' ? 'do 18' : 'do 27'}
</strong></span>
{renderTime && <span>Czas: <strong style={{ color: '#00d4ff' }}>{renderTime}ms</strong></span>}
</div>
{mode === 'naive' && (
<>
<p style={{ color: '#ff4444', fontSize: '12px', marginBottom: '8px' }}>
Uwaga: renderowanie {data.length.toLocaleString()} elementów DOM - może być wolne!
</p>
<NaiveList items={data.slice(0, 500)} itemHeight={ITEM_HEIGHT} />
<p style={{ color: '#778da9', fontSize: '11px', marginTop: '4px' }}>
(Ograniczone do 500 dla bezpieczeństwa przeglądarki)
</p>
</>
)}
{mode === 'virtual' && (
<VirtualizedList
items={data}
itemHeight={ITEM_HEIGHT}
containerHeight={CONTAINER_HEIGHT}
/>
)}
{mode === 'grid' && (
<VirtualizedGrid items={data} containerHeight={CONTAINER_HEIGHT} />
)}
<div style={{
marginTop: '20px', padding: '16px',
background: 'rgba(255, 215, 0, 0.06)', borderRadius: '10px',
fontSize: '13px', color: '#c0c8d0',
}}>
<strong style={{ color: '#ffd700' }}>Jak działa wirtualizacja:</strong>
<ul style={{ margin: '8px 0', paddingLeft: '20px', lineHeight: '1.8' }}>
<li>Zamiast renderować 10 000 elementów, renderujemy tylko widoczne i kilka zapasowych</li>
<li>Używamy jednego dużego kontenera (phantom) dla scrollbara</li>
<li>Przesuwamy widoczne elementy na odpowiednią pozycję</li>
<li>Overscan (bufor) zapobiega miganiu przy szybkim przewijaniu</li>
</ul>
</div>
</div>
</div>
);
}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. Na czym polega wirtualizacja (windowing) list w React?
2. Jak biblioteka react-window implementuje wirtualizację list?
Zadania praktyczne w grze
- Edytor kodu
Katalog ma 100 000 gwiazd, a okno listy mieści tylko 10 wierszy po 40 px. Uzupełnij wirtualizację: ___BLANK1___ to wartość ze stanu, która mówi, o ile pikseli przewinięto okno, ___BLANK2___ to metoda tablicy, która wycina gwiazdy od indeksu start do end, a ___BLANK3___ to indeks gwiazdy w pełnej liście (pole obiektu star), od którego zależy pozycja top wiersza. W DOM ma być tylko kilkanaście wierszy, a po przewinięciu mają się pojawić właściwe gwiazdy na właściwej wysokości. Przewiń listę w podglądzie i sprawdź numery gwiazd.
- Układanie w poziomie
Ułóż składnię komponentu List z react-window 2.x:
- Edytor kodu
Formularz rejestracji załogi składa się z trzech pól CrewField. Każde pole ma etykietę i tekst pomocniczy, a komponent może pojawić się na ekranie wiele razy. Uzupełnij luki: ___BLANK1___ to hook Reacta, który generuje unikalny i stabilny identyfikator dla tej instancji pola, ___BLANK2___ to identyfikator, który etykieta wskazuje przez htmlFor, a ___BLANK3___ to identyfikator akapitu z tekstem pomocniczym, który pole wskazuje przez aria-describedby. Kliknięcie etykiety w podglądzie ma ustawić kursor w polu, a dwa takie formularze na jednej stronie nie mogą mieć wspólnych identyfikatorów.