0Pricing
React Academy · Aula

useTransition para atualizações de interface não bloqueantes

Envolva atualizações de estado dispendiosas em startTransition para manter a interface responsiva.

useTransition para atualizações de interface não bloqueantes é uma aula grátis de React Academy no CoddyKit. Esta é a aula 2 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á o gancho useTransition para marcar atualizações de estado dispendiosas como não urgentes, mantendo a interface responsiva enquanto a renderização pesada acontece em segundo plano.

O problema da atualização bloqueante

Quando você digita em uma caixa de pesquisa que filtra uma lista grande, o React precisa renderizar novamente toda a lista filtrada a cada tecla pressionada. Isso impede que a entrada seja atualizada imediatamente, fazendo a interface parecer lenta.

Modo concorrente do React

O React 18 introduziu a renderização concorrente: o React pode começar a renderizar uma atualização de estado, pausá-la e dar prioridade a atualizações mais urgentes (como a digitação). useTransition é o gancho que permite classificar atualizações como transições de baixa prioridade.

Noções básicas de useTransition

useTransition retorna `[isPending, startTransition]`. Envolva a atualização de estado não urgente em `startTransition()`. O React dará prioridade a outras atualizações (como uma entrada controlada) em vez da transição.
const [isPending, startTransition] = useTransition();

const handleChange = (e) => {
  setInputValue(e.target.value); // urgent: update input immediately
  startTransition(() => {
    setFilteredList(filter(e.target.value)); // non-urgent
  });
};

isPending para a interface de carregamento

Enquanto a transição está sendo processada, `isPending` é `true`. Use-o para mostrar um indicador de carregamento ou escurecer a lista de resultados desatualizada, dando ao usuário um retorno de que uma atualização está em andamento.
return (
  <>
    <input value={inputValue} onChange={handleChange} />
    {isPending && <Spinner />}
    <ResultList items={filteredList} />
  </>
);

O que deve ficar dentro de startTransition

Coloque apenas atualizações de estado dentro de startTransition — não operações assíncronas. É a atualização de estado que dispara a renderização dispendiosa que deve ser envolvida.
// Correct
startTransition(() => setTab('heavy'));

// Wrong — async work outside React state
startTransition(async () => { await fetch(...); }); // not supported

startTransition sem o gancho

Se você não precisa de `isPending`, pode importar e chamar `startTransition` diretamente do React, sem usar o gancho.
import { startTransition } from 'react';

startTransition(() => setQuery(newValue));

Exemplo de troca de abas

Um caso de uso comum: clicar em uma aba troca um componente pesado. Envolva a mudança de aba em startTransition para que o indicador da aba ativa seja atualizado imediatamente, enquanto o componente pesado é renderizado em segundo plano.
const [tab, setTab] = useState('posts');
const [isPending, startTransition] = useTransition();

const selectTab = (t) =>
  startTransition(() => setTab(t));

useTransition versus useDeferredValue

useTransition é para quando você OWN a atualização de estado (você chama setState). useDeferredValue é para quando você recebe uma propriedade ou um valor cuja atualização não pode atrasar diretamente — ele adia o próprio valor.

Não substitui a otimização

startTransition não torna a renderização mais rápida — apenas a adia. Se um componente leva 500 ms para ser renderizado, ele continuará levando 500 ms. Combine-o com React.memo ou virtualização para listas realmente lentas.

Verificação rápida

O que isPending de useTransition representa?

Recapitulação

useTransition permite classificar atualizações de estado como transições não urgentes. Atualizações urgentes (como a entrada) são renderizadas imediatamente; as transições são renderizadas quando o React tem capacidade. Use isPending para mostrar um retorno de carregamento.

A seguir

Próxima lição: **useDeferredValue para o atraso da entrada** — você adiará a renderização novamente das partes lentas da interface, mantendo a entrada rápida e responsiva.

Perguntas Frequentes

A aula “useTransition para atualizações de interface não bloqueantes” é grátis?

Sim — o texto completo de “useTransition para atualizações de interface não bloqueantes” é 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 “useTransition para atualizações de interface não bloqueantes”?

Envolva atualizações de estado dispendiosas em startTransition para manter a interface responsiva. 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 2 de 4.

Quanto tempo leva a aula “useTransition para atualizações de interface não bloqueantes”?

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