Kurs JavaScript i React · Moduł 11: Pobieranie danych i API
Paginacja i Infinite Scroll
W tej lekcji3
Gdy nasz kosmiczny katalog zawiera tysiące obiektów, nie możemy pobrać ich wszystkich naraz: to przeciążyłoby zarówno serwer, jak i przeglądarkę, a użytkownik i tak zobaczy najpierw tylko kilka pierwszych. Rozwiązaniem jest paginacja, czyli dzielenie danych na mniejsze porcje (strony). W tej lekcji poznasz dwa sposoby, w jakie serwer dzieli dane, i trzy sposoby, w jakie interfejs je doczytuje: przyciski stron, przycisk "Załaduj więcej" i automatyczny infinite scroll.
Dwa typy paginacji
1. Paginacja offsetowa (tradycyjna)
Serwer zwraca określoną liczbę elementów, począwszy od konkretnego przesunięcia (offsetu). Najczęściej podajesz numer strony i limit, a serwer liczy offset jako (page - 1) * limit. API SWAPI, którego używamy, zwraca po 10 elementów na stronę oraz pole count z liczbą wszystkich wyników:
// URL: /api/planets?page=1&limit=10
// Zwraca elementy 1-10
// URL: /api/planets?page=2&limit=10
// Zwraca elementy 11-20
function PaginatedList() {
const [data, setData] = useState([]);
const [page, setPage] = useState(1);
const [totalPages, setTotalPages] = useState(1);
const [loading, setLoading] = useState(true);
useEffect(() => {
async function fetchPage() {
setLoading(true);
const response = await fetch(
`https://swapi.dev/api/planets/?page=${page}`
);
const result = await response.json();
setData(result.results);
setTotalPages(Math.ceil(result.count / 10));
setLoading(false);
}
fetchPage();
}, [page]);Numer strony jest zwykłym stanem, a efekt ma go w zależnościach, więc zmiana page sama wywołuje nowe zapytanie. Liczbę stron wyliczamy z count przez Math.ceil, bo ostatnia strona może być niepełna. Druga część komponentu to lista i przyciski:
return (
<div>
{loading ? (
<p>Ładowanie strony {page}...</p>
) : (
data.map(planet => (
<div key={planet.name}>{planet.name}</div>
))
)}
<div className="pagination">
<button
onClick={() => setPage(p => p - 1)}
disabled={page === 1}
>
Poprzednia
</button>
<span>Strona {page} z {totalPages}</span>
<button
onClick={() => setPage(p => p + 1)}
disabled={page === totalPages}
>
Następna
</button>
</div>
</div>
);
}Przyciski blokują się na krańcach, więc nie poprosimy o stronę 0. Każda strona zastępuje poprzednią w data, a nie dopisuje się do niej. Dla zwięzłości pominęliśmy tu obsługę błędów i AbortController z poprzednich lekcji, w prawdziwym kodzie je dodaj.
2. Paginacja kursorowa
Zamiast numeru strony serwer zwraca kursor, czyli wskaźnik do następnej porcji danych (np. id ostatniego elementu). Jest wydajniejsza dla dużych zbiorów danych, bo baza nie musi przeskakiwać tysięcy wierszy, i stabilna, gdy w międzyczasie ktoś doda nowe elementy:
function CursorPaginatedList() {
const [items, setItems] = useState([]);
const [nextCursor, setNextCursor] = useState(null);
const [loading, setLoading] = useState(false);
const loadMore = async () => {
setLoading(true);
const url = nextCursor
? `/api/stars?cursor=${nextCursor}&limit=20`
: '/api/stars?limit=20';
const response = await fetch(url);
const data = await response.json();
setItems(prev => [...prev, ...data.items]);
setNextCursor(data.nextCursor); // null jeżeli brak następnych
setLoading(false);
};
useEffect(() => {
loadMore();
}, []);
return (
<div>
{items.map(item => (
<div key={item.id}>{item.name}</div>
))}
{nextCursor && (
<button onClick={loadMore} disabled={loading}>
{loading ? 'Ładowanie...' : 'Załaduj więcej'}
</button>
)}
</div>
);
}Tu nowe elementy dopisujemy do starych przez spread: [...prev, ...data.items]. Gdy serwer zwróci nextCursor równe null, przycisk znika, bo nie ma już czego ładować. Minusem jest brak skoku "na stronę 7", dlatego kursory pasują do list przewijanych, a offset do tabel z numerami stron.
Przycisk "Załaduj więcej"
SWAPI stosuje wygodny wariant: w odpowiedzi zwraca pole next z gotowym adresem następnej strony albo null na końcu. Trzymamy więc w stanie po prostu następny URL:
function LoadMoreList() {
const [planets, setPlanets] = useState([]);
const [nextUrl, setNextUrl] = useState(
'https://swapi.dev/api/planets/'
);
const [loading, setLoading] = useState(false);
const loadMore = async () => {
if (!nextUrl || loading) return;
setLoading(true);
try {
const response = await fetch(nextUrl);
const data = await response.json();
setPlanets(prev => [...prev, ...data.results]);
setNextUrl(data.next); // URL następnej strony lub null
} catch (err) {
console.error(err);
} finally {
setLoading(false);
}
};
useEffect(() => {
loadMore();
}, []);
return (
<div>
<h2>Katalog planet ({planets.length})</h2>
{planets.map(planet => (
<div key={planet.name} className="planet-card">
<h3>{planet.name}</h3>
<p>Klimat: {planet.climate}</p>
</div>
))}
{nextUrl && (
<button onClick={loadMore} disabled={loading}>
{loading ? 'Skanowanie...' : 'Odkryj więcej planet'}
</button>
)}
{!nextUrl && planets.length > 0 && (
<p>Przeskanowano całą galaktykę!</p>
)}
</div>
);
}Strażnik if (!nextUrl || loading) return chroni przed podwójnym kliknięciem i przed pytaniem o nieistniejącą stronę. W trybie deweloperskim ze StrictMode efekt startowy uruchomi się dwa razy i pierwsza strona może się zdublować. Rozwiązaniem jest flaga ignore albo AbortController z lekcji o race conditions.
Infinite Scroll z IntersectionObserver
Infinite scroll ładuje dane automatycznie, gdy użytkownik dojedzie do końca listy. Pomaga w tym IntersectionObserver, natywne API przeglądarki, które powiadamia, gdy obserwowany element pojawi się w widocznym obszarze (viewporcie). Obserwatora trzymamy w useRef, żeby przetrwał rendery, a do ostatniego elementu podpinamy ref callback, czyli funkcję, którą React wywołuje z węzłem DOM:
import { useRef, useCallback } from 'react';
function InfiniteScrollList() {
const [items, setItems] = useState([]);
const [page, setPage] = useState(1);
const [hasMore, setHasMore] = useState(true);
const [loading, setLoading] = useState(false);
const observer = useRef();
// Ref callback - uruchomi się gdy ostatni element
// pojawi się na ekranie
const lastItemRef = useCallback(node => {
if (loading) return;
// Odłącz poprzedni observer
if (observer.current) observer.current.disconnect();
observer.current = new IntersectionObserver(entries => {
if (entries[0].isIntersecting && hasMore) {
setPage(prev => prev + 1);
}
});
if (node) observer.current.observe(node);
}, [loading, hasMore]);useCallback sprawia, że ref callback zmienia się tylko razem z loading lub hasMore. Wtedy React odpina starą funkcję i podpina nową, a my rozłączamy poprzedniego obserwatora przez disconnect(). Od React 19 ref callback może też zwrócić funkcję sprzątającą. Samo pobieranie wygląda znajomo:
useEffect(() => {
async function loadPage() {
setLoading(true);
const response = await fetch(
`https://swapi.dev/api/people/?page=${page}`
);
const data = await response.json();
setItems(prev => [...prev, ...data.results]);
setHasMore(data.next !== null);
setLoading(false);
}
loadPage();
}, [page]);
return (
<div>
{items.map((item, index) => {
// Przypnij ref do ostatniego elementu
if (index === items.length - 1) {
return (
<div ref={lastItemRef} key={item.name}>
{item.name}
</div>
);
}
return <div key={item.name}>{item.name}</div>;
})}
{loading && <p>Ładowanie kolejnych...</p>}
{!hasMore && <p>Koniec listy</p>}
</div>
);
}Gdy ostatni element listy staje się widoczny, obserwator zwiększa page, efekt pobiera następną stronę i dopisuje ją do listy. setHasMore(data.next !== null) zatrzymuje cały mechanizm na końcu danych. Infinite scroll polecam do przeglądania, jak w kanale aktualności, ale do katalogu, w którym ktoś chce wrócić do konkretnego miejsca, lepiej sprawdzą się strony. W projekcie końcowym użyjesz właśnie paginacji z przyciskami.
Pamiętaj: galaktykę skanuje się sektor po sektorze, bo nikt nie pobiera całego wszechświata jednym zapytaniem.
Kod do tej lekcji: App.jsx
import React, { useState, useEffect, useRef, useCallback } from 'react';
function PaginatedExplorer() {
const [mode, setMode] = useState('pages'); // 'pages' or 'infinite'
return (
<div className="app">
<h1>Kosmiczny Katalog</h1>
<div className="mode-toggle">
<button
className={"mode-btn" + (mode === 'pages' ? " active" : "")}
onClick={() => setMode('pages')}
>
Paginacja
</button>
<button
className={"mode-btn" + (mode === 'infinite' ? " active" : "")}
onClick={() => setMode('infinite')}
>
Infinite Scroll
</button>
</div>
{mode === 'pages' ? <PagedList /> : <InfiniteList />}
</div>
);
}
// Paginacja tradycyjna
function PagedList() {
const [data, setData] = useState(null);
const [page, setPage] = useState(1);
const [loading, setLoading] = useState(true);
useEffect(() => {
setLoading(true);
fetch(`https://swapi.dev/api/people/?page=${page}`)
.then(res => res.json())
.then(result => {
setData(result);
setLoading(false);
})
.catch(() => setLoading(false));
}, [page]);
const totalPages = data ? Math.ceil(data.count / 10) : 1;
return (
<div>
{loading ? (
<div className="loading"><div className="spinner"></div></div>
) : data ? (
<>
<p className="count">Znaleziono: {data.count} postaci</p>
<div className="card-list">
{data.results.map(person => (
<div key={person.name} className="card">
<h3>{person.name}</h3>
<p>Wzrost: {person.height}cm | Waga: {person.mass}kg</p>
<p>Rok ur.: {person.birth_year}</p>
</div>
))}
</div>
<div className="pagination">
<button onClick={() => setPage(p => p - 1)} disabled={page === 1}>
Poprzednia
</button>
<span>Strona {page} z {totalPages}</span>
<button onClick={() => setPage(p => p + 1)} disabled={page >= totalPages}>
Nastepna
</button>
</div>
</>
) : null}
</div>
);
}
// Infinite Scroll
function InfiniteList() {
const [items, setItems] = useState([]);
const [page, setPage] = useState(1);
const [hasMore, setHasMore] = useState(true);
const [loading, setLoading] = useState(false);
const observer = useRef();
const lastItemRef = useCallback(node => {
if (loading) return;
if (observer.current) observer.current.disconnect();
observer.current = new IntersectionObserver(entries => {
if (entries[0].isIntersecting && hasMore) {
setPage(prev => prev + 1);
}
});
if (node) observer.current.observe(node);
}, [loading, hasMore]);
useEffect(() => {
setLoading(true);
fetch(`https://swapi.dev/api/people/?page=${page}`)
.then(res => res.json())
.then(result => {
setItems(prev => [...prev, ...result.results]);
setHasMore(result.next !== null);
setLoading(false);
})
.catch(() => setLoading(false));
}, [page]);
return (
<div>
<p className="count">Zaladowano: {items.length} postaci</p>
<div className="card-list">
{items.map((person, index) => (
<div
key={person.name + index}
className="card"
ref={index === items.length - 1 ? lastItemRef : null}
>
<h3>{person.name}</h3>
<p>Wzrost: {person.height}cm | Waga: {person.mass}kg</p>
<p>Rok ur.: {person.birth_year}</p>
</div>
))}
</div>
{loading && <div className="loading"><div className="spinner"></div></div>}
{!hasMore && <p className="end">Koniec listy - przeskanowano cala galaktyke!</p>}
</div>
);
}
export default PaginatedExplorer;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. Jaka jest główna różnica między paginacją offsetową (page/limit) a kursorową (cursor)?
2. Która właściwość odpowiedzi API z paginacją zawiera URL do pobrania następnej strony wyników?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż składnię dodawania nowych elementów do istniejących w paginacji (spread operator):
- Układanie w pionie
Ułóż kolejność kroków implementacji infinite scroll z IntersectionObserver:
- Edytor kodu
Paginacja z przyciskami
- Edytor kodu
Przycisk Load More
- Układanie w pionie
Ułóż kolejność elementów pełnego wzorca data fetchingu w React (od początku do końca):
- Układanie w poziomie
Ułóż składnię sprawdzenia, czy są kolejne strony do pobrania:
- Klikanie w kolejności
Kliknij elementy w kolejności tworzenia IntersectionObserver w React:
- Układanie w pionie
Ułóż kody statusu HTTP od sukcesu do najpoważniejszego błędu:
- Układanie w poziomie
Ułóż składnię debouncing z setTimeout w useEffect:
- Układanie w pionie
Ułóż techniki data fetchingu od najprostszej do najbardziej zaawansowanej:
Zadania po tej lekcji
- Ułóż w kolejnościDodawanie nowych danych do listy
- Ułóż w kolejnościKroki implementacji infinite scroll
- PytaniePaginacja offsetowa vs kursorowa
- Zadanie z kodemPraktyka: Paginacja tradycyjna
- Zadanie z kodemPraktyka: Load More button
- PytaniePaginacja w odpowiedzi API
- Ułóż w kolejnościWzorzec fetchowania danych w React
- Ułóż w kolejnościWarunek sprawdzenia hasMore w paginacji
- Kliknij w kolejnościInicjalizacja IntersectionObserver
- Ułóż w kolejnościKody statusu HTTP od sukcesu do błędu
- Ułóż w kolejnościDebounce z setTimeout w useEffect
- PytanieKonfiguracja zapytania POST z fetch
- Ułóż w kolejnościOd podstawowego fetch do zaawansowanych wzorców