Kurs JavaScript i React · Moduł 16: Obsługa błędów i Suspense

Fallback UI i Skeleton Loaders

5 min czytania ·
W tej lekcji5

Wyobraź sobie że otwierasz panel nawigacyjny, a przez dwie sekundy widzisz pusty, czarny ekran. Czy system się zawiesił? Czy statek w ogóle odpowiada? Po chwili nagle wyskakuje cały panel i przesuwa przyciski, w które właśnie celowałeś. To nie jest awaria, a jednak załoga traci zaufanie do stacji. W kosmosie, gdy moduł stacji jest w trakcie inicjalizacji, załoga widzi wskaźniki postępu i holograficzne kontury przyszłego interfejsu. W React mamy skeleton loadery i fallback UI - elementy zastępczego interfejsu, które informują użytkownika o trwającym ładowaniu.

Dlaczego Fallback UI jest ważny?

Dobre ładowanie to nie tylko spinner. Użytkownik powinien mieć poczucie, że coś się dzieje, i wiedzieć, czego się spodziewać. Fallback, który zajmuje tyle miejsca co docelowa treść, zapobiega też skakaniu układu, gdy dane w końcu dotrą.

Poziomy jakości ładowania (od najgorszego do najlepszego)

Porównaj cztery wersje tego samego Suspense. Zmienia się wyłącznie prop fallback, czyli to, co React pokaże, dopóki komponent w środku nie będzie gotowy:

// 1. Nic (najgorsze) - użytkownik nie wie co się dzieje
<Suspense fallback={null}>

// 2. Prosty tekst
<Suspense fallback={<p>Ładowanie...</p>}>

// 3. Spinner/Loader
<Suspense fallback={<Spinner />}>

// 4. Skeleton loader (najlepsze)
<Suspense fallback={<ContentSkeleton />}>

Mechanika ładowania jest w każdym wariancie identyczna, różni się tylko komunikat dla załogi. Dla porządku: Suspense to wbudowany komponent React, który pokazuje fallback, dopóki coś w jego wnętrzu "czeka". Według react.dev reaguje na komponenty ładowane leniwie przez React.lazy() i na obietnice odczytywane hookiem use, a nie na dowolny fetch w efekcie.

Skeleton Loaders

Skeleton loader to zastępczy UI, który naśladuje kształt i układ docelowej treści. Użytkownik widzi "szkielet" strony, który stopniowo wypełnia się prawdziwą treścią. To jak hologram modułu wyświetlany, zanim moduł fizycznie zadokuje do stacji.

Podstawowy Skeleton w CSS

Szkielet karty składa się ze zwykłych, pustych elementów div. Każdy dostaje klasę opisującą jego kształt i wspólną klasę animacji skeleton-pulse:

function CardSkeleton() {
  return (
    <div className="skeleton-card">
      <div className="skeleton-image skeleton-pulse" />
      <div className="skeleton-title skeleton-pulse" />
      <div className="skeleton-text skeleton-pulse" />
      <div className="skeleton-text skeleton-pulse short" />
    </div>
  );
}

Komponent nie ma stanu ani propsów, bo jego jedynym zadaniem jest zająć miejsce. Cały efekt wizualny robi CSS. Gradient linear-gradient tworzy jaśniejszy pas, background-size: 200% 100% sprawia, że tło jest dwa razy szersze od elementu, a reguła @keyframes przesuwa je od prawej do lewej:

.skeleton-pulse {
  background: linear-gradient(
    90deg,
    #e0e0e0 25%,
    #f0f0f0 50%,
    #e0e0e0 75%
  );
  background-size: 200% 100%;
  animation: pulse 1.5s infinite;
  border-radius: 4px;
}

@keyframes pulse {
  0% { background-position: 200% 0; }
  100% { background-position: -200% 0; }
}

.skeleton-image {
  width: 100%;
  height: 200px;
  margin-bottom: 12px;
}

.skeleton-title {
  width: 60%;
  height: 24px;
  margin-bottom: 8px;
}

.skeleton-text {
  width: 100%;
  height: 16px;
  margin-bottom: 6px;
}

.skeleton-text.short {
  width: 40%;
}

Wymiary w klasach .skeleton-image, .skeleton-title i .skeleton-text odpowiadają prawdziwej karcie, więc po załadowaniu nic nie przeskoczy. Klasa .short skraca ostatnią linię, bo prawdziwy akapit rzadko kończy się równo z krawędzią.

Skeleton dla różnych typów treści

Jeden szkielet nie pasuje do wszystkiego. Lista załogi wygląda inaczej niż pulpit ze statystykami, więc budujemy osobne kształty.

Lista elementów

Szkielet listy przyjmuje prop count, a Array.from({ length: count }) tworzy tablicę o tej długości, po której możemy iterować:

function ListSkeleton({ count = 3 }) {
  return (
    <div className="list-skeleton">
      {Array.from({ length: count }).map((_, i) => (
        <div key={i} className="list-item-skeleton">
          <div className="avatar-skeleton skeleton-pulse" />
          <div className="info-skeleton">
            <div className="skeleton-pulse name-skeleton" />
            <div className="skeleton-pulse detail-skeleton" />
          </div>
        </div>
      ))}
    </div>
  );
}

Tutaj indeks jako key jest w porządku, bo elementy nigdy nie zmieniają kolejności ani nie mają własnego stanu.

Dashboard z wieloma sekcjami

Większe szkielety składasz z mniejszych, dokładnie tak jak prawdziwy pulpit składa się z kart i list:

function DashboardSkeleton() {
  return (
    <div className="dashboard-skeleton">
      <div className="stats-row">
        <StatCardSkeleton />
        <StatCardSkeleton />
        <StatCardSkeleton />
      </div>
      <div className="main-content">
        <ChartSkeleton />
        <ListSkeleton count={5} />
      </div>
    </div>
  );
}

Układ siatki jest ten sam co w docelowym pulpicie, zmieniają się tylko klocki w środku.

Wzorce ładowania

Progressive Loading

Ładuj ważne treści najpierw, reszta ładuje się w tle. Każda mniej ważna sekcja dostaje własny Suspense, więc nie blokuje pozostałych:

function MissionDashboard() {
  return (
    <div>
      {/* Krytyczna treść - bez lazy loading */}
      <MissionStatus />

      {/* Mniej krytyczna - lazy loading z skeleton */}
      <Suspense fallback={<ChartSkeleton />}>
        <MissionChart />
      </Suspense>

      {/* Najmniej ważna - ładuje się ostatnia */}
      <Suspense fallback={<ListSkeleton count={5} />}>
        <MissionHistory />
      </Suspense>
    </div>
  );
}

Zakładamy tu, że MissionChart i MissionHistory są komponentami z React.lazy(). MissionStatus jest importowany normalnie, więc pojawia się od razu i nie ma własnego fallbacku.

Inline Loading States

Nie zawsze potrzebujesz Suspense. Dla danych ładowanych asynchronicznie w efekcie używaj stanów ładowania, bo Suspense nie wie o fetch wywołanym w useEffect:

function CrewMember({ id }) {
  const [member, setMember] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    setLoading(true); // Nowe id - znowu pokazujemy skeleton
    fetchCrewMember(id)
      .then(setMember)
      .finally(() => setLoading(false));
  }, [id]);

  if (loading) return <MemberSkeleton />;

  return (
    <div className="crew-member">
      <img src={member.avatar} alt={member.name} />
      <h3>{member.name}</h3>
      <p>{member.role}</p>
    </div>
  );
}

Linia setLoading(true) na początku efektu sprawia, że po zmianie id szkielet wraca, zamiast przez chwilę pokazywać poprzedniego członka załogi. finally wyłącza ładowanie zarówno po sukcesie, jak i po błędzie. Samą obsługę błędu dodasz w następnej lekcji.

Dobre praktyki

  1. Skeleton powinien odwzorowywać układ treści - taki sam rozmiar i kształt
  2. Animacja pulsu - daje poczucie, że coś się dzieje
  3. Unikaj migotania - jeśli ładowanie trwa <300ms, nie pokazuj skeletonów
  4. Użyj różnych skeletonów dla różnych typów treści
  5. Zachowaj proporcje - skeleton powinien zajmować tyle samo miejsca co prawdziwa treść

Z punktem 3 React częściowo pomaga sam: według react.dev odsłania zawieszoną treść najwyżej raz na 300 ms, więc granice gotowe w tym oknie pojawiają się razem. Moja rada: zawsze zaczynaj od szkieletu, spinner zostaw na krótkie akcje w przyciskach. W następnej lekcji połączysz szkielety z granicami błędów, żeby moduł, który się nie załaduje, nie zostawił pustej dziury.

Pamiętaj: dobry szkielet to hologram modułu, który pokazuje załodze kształt tego, co za chwilę zadokuje.

Kod do tej lekcji: App.jsx
import React, { useState, useEffect } from 'react';
import './styles.css';

// Skeleton dla karty misji
function MissionCardSkeleton() {
  return (
    <div className="card skeleton-card">
      <div className="skeleton-img skeleton-pulse" />
      <div className="skeleton-h skeleton-pulse" />
      <div className="skeleton-p skeleton-pulse" />
      <div className="skeleton-p skeleton-pulse short" />
    </div>
  );
}

// Skeleton dla listy czlonkow zalogi
function CrewListSkeleton({ count = 3 }) {
  return (
    <div className="crew-skeleton">
      {Array.from({ length: count }).map((_, i) => (
        <div key={i} className="crew-item-skel">
          <div className="avatar-skel skeleton-pulse" />
          <div className="crew-info-skel">
            <div className="skeleton-name skeleton-pulse" />
            <div className="skeleton-role skeleton-pulse" />
          </div>
        </div>
      ))}
    </div>
  );
}

// Prawdziwa karta misji
function MissionCard({ mission }) {
  return (
    <div className="card">
      <div className="card-icon">{mission.icon}</div>
      <h3>{mission.name}</h3>
      <p>{mission.description}</p>
      <span className={`badge ${mission.status}`}>{mission.status}</span>
    </div>
  );
}

// Prawdziwa lista zalogi
function CrewList({ members }) {
  return (
    <div className="crew-list">
      {members.map(m => (
        <div key={m.id} className="crew-item">
          <div className="avatar">{m.avatar}</div>
          <div>
            <strong>{m.name}</strong>
            <p className="role">{m.role}</p>
          </div>
        </div>
      ))}
    </div>
  );
}

export default function App() {
  const [missions, setMissions] = useState(null);
  const [crew, setCrew] = useState(null);

  useEffect(() => {
    // Symulacja ladowania misji (szybsze)
    setTimeout(() => {
      setMissions([
        { id: 1, icon: '', name: 'Eksploracja Marsa', description: 'Badanie powierzchni', status: 'active' },
        { id: 2, icon: '', name: 'Zwiad Jowisza', description: 'Analiza atmosfery', status: 'pending' },
      ]);
    }, 1200);

    // Symulacja ladowania zalogi (wolniejsze)
    setTimeout(() => {
      setCrew([
        { id: 1, avatar: '', name: 'Kapitan Nova', role: 'Dowodca' },
        { id: 2, avatar: '', name: 'Dr. Stellar', role: 'Naukowiec' },
        { id: 3, avatar: '', name: 'Tech Orion', role: 'Inzynier' },
      ]);
    }, 2500);
  }, []);

  return (
    <div className="app">
      <h1>Skeleton Loaders</h1>
      <p className="subtitle">Obserwuj jak skeletony zamieniaja sie w tresc</p>

      <section>
        <h2>Misje</h2>
        {missions ? (
          <div className="cards-grid">
            {missions.map(m => <MissionCard key={m.id} mission={m} />)}
          </div>
        ) : (
          <div className="cards-grid">
            <MissionCardSkeleton />
            <MissionCardSkeleton />
          </div>
        )}
      </section>

      <section>
        <h2>Zaloga</h2>
        {crew ? <CrewList members={crew} /> : <CrewListSkeleton count={3} />}
      </section>
    </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. Dlaczego skeleton loader jest lepszy od prostego spinnera?

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj MissionCardSkeleton

  • Układanie w pionie

    Uporządkuj poziomy jakości ładowania od najgorszego do najlepszego:

  • Klikanie w kolejności

    Kliknij elementy w kolejności budowania animacji skeleton pulse:

  1. PytanieSkeleton loader vs spinner
  2. Zadanie z kodemPraktyka: Skeleton Loader dla kart misji
  3. Ułóż w kolejnościPoziomy jakości ładowania
  4. Kliknij w kolejnościTworzenie animacji skeleton pulse w CSS

Przydatne artykuły