Kurs JavaScript i React · Moduł 8: Zaawansowane wzorce React

Concurrent Mode i Suspense

5 min czytania ·
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?

APIZastosowaniePrzykład
startTransitionAktualizacje, które mogą poczekaćZmiana filtrów, nawigacja między zakładkami
useTransitionJak wyżej + wskaźnik ładowaniaPrzełączanie widoków z loading state
SuspenseOczekiwanie na dane lub kodLazy loading, pobieranie danych
useDeferredValueOpóźnienie renderowania wartościFiltrowanie 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. 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

  1. Ułóż w kolejnościstartTransition w React
  2. PytanieWprowadzenie: Kiedy używać HOC vs Custom Hooks
  3. Zadanie z kodemWprowadzenie: Praktyka: Compound components
  4. Ułóż w kolejnościKroki tworzenia custom hooka
  5. Zadanie z kodemPraktyka: State machine

Przydatne artykuły