0Pricing
React Academy · Lezione

useDeferredValue per il debounce degli input

Ritardi i re-render delle parti lente dell'interfaccia mantenendo reattivi gli input.

useDeferredValue per il debounce degli input è una lezione React Academy gratuita su CoddyKit. Questa è la lezione 3 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 userà useDeferredValue per ritardare il rendering delle parti costose dell'interfaccia, mantenendo gli input controllati reattivi e veloci.

Che cos'è useDeferredValue

useDeferredValue accetta un valore e restituisce una versione differita. Durante i rendering urgenti, il valore differito resta indietro rispetto a quello corrente, consentendo a React di aggiornare l'interfaccia in due fasi: rapidamente per l'input e in modo differito per l'output costoso.
const [query, setQuery] = useState('');
const deferredQuery = useDeferredValue(query);
// query updates immediately on keystroke
// deferredQuery updates when React has capacity

Applicazione ai componenti costosi

Passi il valore differito, non quello corrente, al componente costoso. Il componente costoso viene renderizzato nuovamente solo quando cambia deferredQuery, che durante la digitazione veloce resta indietro rispetto all'input.
function App() {
  const [q, setQ] = useState('');
  const dq = useDeferredValue(q);
  return (
    <>
      <input value={q} onChange={e => setQ(e.target.value)} />
      <HeavyList query={dq} /> {/* renders with deferred value */}
    </>
  );
}

Mostrare un indicatore di contenuto obsoleto

Confronti il valore corrente con quello differito. Quando sono diversi, il contenuto è obsoleto e può attenuarlo con opacity oppure mostrare uno spinner di caricamento.
const isStale = q !== dq;
<div style={{ opacity: isStale ? 0.5 : 1 }}>
  <HeavyList query={dq} />
</div>

useDeferredValue e debounce a confronto

Il debounce basato su setTimeout introduce sempre un ritardo fisso, ad esempio 300 ms, anche sui dispositivi veloci. useDeferredValue è adattivo: sui dispositivi veloci esegue il rendering immediatamente, mentre su quelli lenti lo rimanda per evitare scatti.

useDeferredValue e useTransition a confronto

Utilizzi useTransition quando gestisce direttamente il setter dello stato, cioè quando può racchiudere setState. Utilizzi useDeferredValue quando riceve un valore come prop o dal Context e non può controllarne l'aggiornamento.
// You own the state: use useTransition
startTransition(() => setTab(newTab));

// You receive the value: use useDeferredValue
const deferredProp = useDeferredValue(props.searchQuery);

Combinazione con React.memo

Perché useDeferredValue possa evitare efficacemente i re-render, il componente costoso deve essere racchiuso in React.memo. Senza, il componente viene renderizzato nuovamente ogni volta che il componente padre esegue il rendering, indipendentemente dal valore differito.
const HeavyList = React.memo(function({ query }) {
  // expensive rendering
  return <ul>{data.filter(q => ...).map(...)}</ul>;
});

Il valore differito al rendering iniziale

Al rendering iniziale, il valore differito è uguale a quello corrente: non c'è alcun ritardo. Il differimento entra in gioco solo quando, durante un nuovo rendering, i valori corrente e differito sono diversi.

Più valori differiti

Può chiamare useDeferredValue più volte per diverse parti costose dell'interfaccia; ogni valore viene differito in modo indipendente.
const deferredA = useDeferredValue(valueA);
const deferredB = useDeferredValue(valueB);

Limitazioni

useDeferredValue non rende più veloce il rendering: lo ritarda soltanto. Se il rendering costoso impiega 500 ms, l'interfaccia continuerà a presentare scatti. Lo combini con la virtualizzazione (react-virtual) per gli elenchi veramente grandi.

Verifica rapida

Quando useDeferredValue offre un vantaggio rispetto a un valore normale?

Riepilogo

useDeferredValue restituisce una versione ritardata di un valore. La passi a componenti costosi racchiusi in React.memo. Mostri un indicatore di contenuto obsoleto quando deferredValue !== value. Lo preferisca al debounce con ritardo fisso per ottenere prestazioni adattive.

Prossima lezione

Prossima lezione: **Suspense per i confini di dati e codice**: combinerà Suspense con il caricamento lazy e le librerie per i dati per ottenere stati di caricamento chiari.

Domande Frequenti

La lezione «useDeferredValue per il debounce degli input» è gratuita?

Sì — il testo completo di «useDeferredValue per il debounce degli input» è 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 «useDeferredValue per il debounce degli input»?

Ritardi i re-render delle parti lente dell'interfaccia mantenendo reattivi gli input. 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 3 di 4.

Quanto tempo richiede la lezione «useDeferredValue per il debounce degli input»?

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. Race condition e pulizia degli effect
  2. useTransition per aggiornamenti UI non bloccanti
  3. useDeferredValue per il debounce degli input
  4. Suspense per i confini di dati e codice
← Torna a React Academy