0Pricing
React Academy · Aula

useDeferredValue para controlar a frequência de entradas

Atrase as novas renderizações das partes lentas da interface enquanto mantém as entradas ágeis.

useDeferredValue para controlar a frequência de entradas é uma aula grátis de React Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de React Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de React Academy inclui 4 aulas no total.

Boas-vindas

Nesta lição, você usará useDeferredValue para adiar a renderização novamente das partes dispendiosas da interface, mantendo as entradas controladas rápidas e responsivas.

O que é useDeferredValue?

useDeferredValue aceita um valor e retorna uma versão adiada dele. O valor adiado fica atrás do valor atual durante renderizações urgentes, permitindo que o React atualize a interface em duas etapas: rapidamente para a entrada e de forma adiada para a saída dispendiosa.
const [query, setQuery] = useState('');
const deferredQuery = useDeferredValue(query);
// query updates immediately on keystroke
// deferredQuery updates when React has capacity

Aplicação a componentes dispendiosos

Passe o valor adiado (não o valor atual) ao componente dispendioso. O componente dispendioso será renderizado novamente apenas quando deferredQuery mudar — e ele fica atrás da entrada durante uma digitação rápida.
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 */}
    </>
  );
}

Exibição de um indicador de conteúdo desatualizado

Compare o valor atual com o valor adiado. Quando forem diferentes, o conteúdo estará desatualizado, e você poderá reduzi-lo com opacidade ou mostrar um indicador de carregamento.
const isStale = q !== dq;
<div style={{ opacity: isStale ? 0.5 : 1 }}>
  <HeavyList query={dq} />
</div>

useDeferredValue versus atraso programado

O atraso programado baseado em setTimeout sempre introduz uma espera fixa (por exemplo, 300 ms), mesmo em máquinas rápidas. useDeferredValue é adaptável: em dispositivos rápidos, renderiza imediatamente; em dispositivos lentos, adia a renderização para evitar travamentos.

useDeferredValue versus useTransition

Use useTransition quando você OWN a função que define o estado (pode envolvê-la em setState). Use useDeferredValue quando recebe um valor como propriedade ou de um contexto e não pode controlar quando ele é atualizado.
// You own the state: use useTransition
startTransition(() => setTab(newTab));

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

Combinação com React.memo

Para que useDeferredValue pule renderizações novamente de forma eficaz, o componente dispendioso precisa ser envolvido em React.memo. Sem isso, o componente será renderizado novamente sempre que o componente pai for renderizado novamente, independentemente do valor adiado.
const HeavyList = React.memo(function({ query }) {
  // expensive rendering
  return <ul>{data.filter(q => ...).map(...)}</ul>;
});

O valor adiado na renderização inicial

Na renderização inicial, o valor adiado é igual ao valor atual — não há atraso. O adiamento só entra em ação quando os valores atual e adiado são diferentes durante uma nova renderização.

Vários valores adiados

Você pode chamar useDeferredValue várias vezes para diferentes partes dispendiosas da interface, adiando cada uma de forma independente.
const deferredA = useDeferredValue(valueA);
const deferredB = useDeferredValue(valueB);

Limitações

useDeferredValue não torna a renderização mais rápida — apenas a atrasa. Se a renderização dispendiosa levar 500 ms, a interface continuará travando. Combine-o com virtualização (react-virtual) para listas realmente grandes.

Verificação rápida

Quando useDeferredValue oferece um benefício em relação a um valor regular?

Recapitulação

useDeferredValue retorna uma versão atrasada de um valor. Passe-a a componentes dispendiosos envolvidos em React.memo. Mostre um indicador de conteúdo desatualizado quando deferredValue !== value. Prefira-o a um atraso fixo para obter um desempenho adaptável.

A seguir

Próxima lição: **Suspense para limites de dados e código** — você combinará Suspense com carregamento tardio e bibliotecas de dados para obter estados de carregamento limpos.

Perguntas Frequentes

A aula “useDeferredValue para controlar a frequência de entradas” é grátis?

Sim — o texto completo de “useDeferredValue para controlar a frequência de entradas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de React Academy, atualize para CoddyKit PRO. O curso de React Academy inclui 4 aulas no total.

O que vou aprender em “useDeferredValue para controlar a frequência de entradas”?

Atrase as novas renderizações das partes lentas da interface enquanto mantém as entradas ágeis. Você pratica React Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar React Academy?

Nenhuma experiência prévia é necessária. React Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “useDeferredValue para controlar a frequência de entradas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de React Academy?

Sim. Cada aula de React Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Condições de corrida e limpeza de efeitos
  2. useTransition para atualizações de interface não bloqueantes
  3. useDeferredValue para controlar a frequência de entradas
  4. Suspense para limites de dados e código
← Voltar para React Academy