Kurs JavaScript i React · Moduł 9: Nowoczesne hooki React

Wirtualizacja list i windowing

15 min czytania ·
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 scrollowanie

Efekty 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 listy

Nie 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 biblioteka

Cięż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:

  1. Renderuj tylko widoczne elementy - użyj react-window lub react-virtuoso
  2. List z liczbą w rowHeight dla elementów o stałej wysokości (najwydajniejsze; w 1.x FixedSizeList)
  3. List z funkcją w rowHeight dla elementów o zmiennej wysokości (w 1.x VariableSizeList), a useDynamicRowHeight, gdy wysokości trzeba zmierzyć
  4. Mierz przed i po - używaj React DevTools Profiler i performance.now()
  5. 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. 1. Na czym polega wirtualizacja (windowing) list w React?

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

  1. PytanieWirtualizacja list w React
  2. Zadanie z kodemPraktyka: Wirtualizacja list
  3. Ułóż w kolejnościSkładnia react-window List (v2)
  4. Pytaniereact-window - zasada działania
  5. Zadanie z kodemPraktyka: useId - formularze z dostępnością

Przydatne artykuły