0Pricing
React Academy · Lezione

Scroll infinito e paginazione con useInfiniteQuery

Recuperi dati paginati e carichi le pagine successive senza interruzioni con useInfiniteQuery.

Scroll infinito e paginazione con useInfiniteQuery è una lezione React Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento React Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso React Academy include 4 lezioni in totale.

Benvenuto

In questa lezione utilizzerà useInfiniteQuery per recuperare dati paginati e implementerà un modello di scorrimento infinito che carica nuove pagine mentre l'utente scorre.

Che cos'è useInfiniteQuery?

useInfiniteQuery recupera i dati organizzandoli in «pagine». Ogni pagina viene recuperata separatamente e aggiunta all'elenco memorizzato nella cache. Fornisce le utilità fetchNextPage, hasNextPage e isFetchingNextPage.

Configurazione di base

Definisca initialPageParam e getNextPageParam. La queryFn riceve il pageParam corrente e deve restituire una pagina di risultati.
const { data, fetchNextPage, hasNextPage } = useInfiniteQuery({
  queryKey: ['posts'],
  queryFn: ({ pageParam }) =>
    fetch('/api/posts?cursor=' + pageParam).then(r => r.json()),
  initialPageParam: 0,
  getNextPageParam: (lastPage) => lastPage.nextCursor ?? undefined,
});

getNextPageParam

getNextPageParam riceve l'ultima pagina recuperata e tutte le pagine. Restituisca il cursore o il numero della pagina successiva, oppure undefined/null per segnalare che non ci sono altre pagine (impostando hasNextPage su false).
getNextPageParam: (lastPage, allPages) => {
  return lastPage.hasMore ? lastPage.nextCursor : undefined;
}

Rendering di tutte le pagine

data.pages è un array di risultati delle pagine. Lo appiattisca per visualizzare tutti gli elementi come un elenco continuo.
const allPosts = data.pages.flatMap(page => page.items);

return (
  <ul>
    {allPosts.map(post => <li key={post.id}>{post.title}</li>)}
  </ul>
);

Pulsante Carica altro

Aggiunga un pulsante «Carica altro» che chiami fetchNextPage. Lo disabiliti quando non ci sono altre pagine o è in corso un recupero.
<button
  onClick={() => fetchNextPage()}
  disabled={!hasNextPage || isFetchingNextPage}
>
  {isFetchingNextPage ? 'Loading...' : hasNextPage ? 'Load More' : 'No more posts'}
</button>

Scroll infinito con IntersectionObserver

Colleghi un IntersectionObserver a un div sentinella in fondo all'elenco. Quando entra nell'area visibile, chiami automaticamente fetchNextPage.
const observerRef = useRef();
useEffect(() => {
  const observer = new IntersectionObserver(entries => {
    if (entries[0].isIntersecting && hasNextPage) fetchNextPage();
  });
  if (observerRef.current) observer.observe(observerRef.current);
  return () => observer.disconnect();
}, [hasNextPage, fetchNextPage]);

<div ref={observerRef} />  {/* sentinel at bottom */}

Scroll infinito bidirezionale

Per le app di chat, supporti lo scorrimento in entrambe le direzioni: usi fetchNextPage per i messaggi meno recenti e getPreviousPageParam/fetchPreviousPage per quelli più recenti.

Paginazione basata su pagina o cursore

Basata su offset/pagina: initialPageParam=1, getNextPageParam restituisce lastPage.page + 1. Basata su cursore: usi l'ID dell'ultimo elemento come cursore. La paginazione basata su cursore è più stabile con i dati in tempo reale.
// Offset-based
getNextPageParam: (lastPage) => lastPage.page + 1

Aggiornamento delle query infinite

Chiamare invalidateQueries su una query infinita aggiorna solo la prima pagina. Per aggiornare tutte le pagine (ad esempio dopo l'aggiunta di un nuovo post), usi queryClient.resetQueries o refetchType: 'all'.

Verifica rapida

Che cosa deve restituire getNextPageParam per segnalare che non ci sono altre pagine da caricare?

Riepilogo

useInfiniteQuery accumula le pagine in data.pages. Le appiattisca con flatMap per visualizzarle. Usi getNextPageParam restituendo undefined per interrompere il caricamento. Attivi fetchNextPage al clic di un pulsante o con IntersectionObserver per ottenere uno scroll infinito.

Corso completato

Congratulazioni! Ha completato **React Query: gestione dello stato del server**. Ora può recuperare, memorizzare nella cache, modificare, paginare e scorrere all'infinito i dati con TanStack Query.

Domande Frequenti

La lezione «Scroll infinito e paginazione con useInfiniteQuery» è gratuita?

Sì — il testo completo di «Scroll infinito e paginazione con useInfiniteQuery» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso React Academy, passa a CoddyKit PRO. Il corso React Academy include 4 lezioni in totale.

Cosa imparerò in «Scroll infinito e paginazione con useInfiniteQuery»?

Recuperi dati paginati e carichi le pagine successive senza interruzioni con useInfiniteQuery. Eserciti React Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare React Academy?

Non è richiesta alcuna esperienza precedente. React Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Scroll infinito e paginazione con useInfiniteQuery»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione React Academy?

Sì. Ogni lezione React Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Configurazione di React Query e QueryClient
  2. Caching, stale time e refetch in background
  3. Mutation con useMutation
  4. Scroll infinito e paginazione con useInfiniteQuery
← Torna a React Academy