Kurs JavaScript i React · Moduł 16: Obsługa błędów i Suspense
Fallback UI i Skeleton Loaders
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
- Skeleton powinien odwzorowywać układ treści - taki sam rozmiar i kształt
- Animacja pulsu - daje poczucie, że coś się dzieje
- Unikaj migotania - jeśli ładowanie trwa <300ms, nie pokazuj skeletonów
- Użyj różnych skeletonów dla różnych typów treści
- 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. 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: