0Pricing
React Academy · Aula

O hook use() para recursos assíncronos

Leia promessas e contextos durante a renderização com o hook use() no React 19.

O hook use() para recursos assíncronos é 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 use() do React 19 para ler promessas e valores de contexto diretamente dentro da função de renderização, simplificando o acesso assíncrono aos dados.

O que é use()?

use() é um gancho do React 19 que lê um recurso — uma Promise ou um Contexto — de forma síncrona na função de renderização. Se a Promise estiver pendente, o componente é suspenso e o limite Suspense mais próximo exibe seu conteúdo alternativo.
import { use } from 'react';

function UserProfile({ userPromise }) {
  const user = use(userPromise); // suspends if pending
  return <h1>{user.name}</h1>;
}

Passando promessas como propriedades

Um padrão comum no React 19 é: o Componente do Servidor cria uma Promise (por exemplo, uma consulta ao banco de dados), passa-a a um Componente do Cliente, e o Componente do Cliente a lê com use(). O limite Suspense pode estar em qualquer ponto acima.
// Server Component
export default function Page() {
  const userPromise = fetchUser(1); // NOT awaited
  return (
    <Suspense fallback={<Spinner />}>
      <Profile userPromise={userPromise} />
    </Suspense>
  );
}

// Client Component
'use client';
export function Profile({ userPromise }) {
  const user = use(userPromise);
  return <p>{user.name}</p>;
}

use() versus useEffect para dados

Usar useEffect para buscar dados exige gerenciar manualmente os estados de carregamento e erro. use() com Suspense elimina todo esse código repetitivo — o corpo do componente apenas lê os dados como se fossem síncronos.

use() para Contexto

use() também pode ler valores de contexto, assim como useContext. A diferença é que use() pode ser chamado condicionalmente (dentro de if ou loops), ao contrário de useContext, que segue as Regras dos Hooks.
import { use } from 'react';
import { ThemeContext } from './ThemeContext';

function Button({ danger }) {
  if (danger) {
    const theme = use(ThemeContext); // conditional — allowed with use()!
    return <button style={{ color: theme.red }}>Delete</button>;
  }
  return <button>Click</button>;
}

Tratamento de erros com ErrorBoundary

Se a Promise passada a use() for rejeitada, o React lançará o erro. Envolva o componente com um ErrorBoundary para capturá-lo e exibir um conteúdo alternativo.
<ErrorBoundary fallback={<Error />}>
  <Suspense fallback={<Loading />}>
    <Profile userPromise={fetchUser(id)} />
  </Suspense>
</ErrorBoundary>

use() somente em Componentes do Cliente

use() com uma Promise funciona em Componentes do Cliente. Nos Componentes do Servidor, use async/await diretamente — não há necessidade de usar use() com Promises no servidor.

Armazenando promessas em cache

Se um componente for renderizado novamente, ele deverá receber a mesma referência de Promise para evitar uma nova busca. Crie Promises fora do componente ou em um local estável (servidor, cache ou estado) e passe-as como propriedades.

Transmissão contínua com use()

Combinar use() com transmissão contínua via SSR permite que o React transmita o HTML da página, mostre o conteúdo alternativo do Suspense e depois transmita o conteúdo resolvido assim que a Promise for resolvida — tudo em uma única conexão HTTP.

React.cache() para deduplicação

No servidor, React.cache() (ou o unstable_cache do Next.js) elimina chamadas duplicadas à mesma função assíncrona durante uma renderização, portanto o banco de dados é consultado apenas uma vez, mesmo que vários componentes usem a mesma promessa.

Verificação rápida

O que um Componente de Cliente faz quando use(promise) é chamado e a promessa ainda está pendente?

Recapitulação

use(promise) lê dados assíncronos de forma síncrona durante a renderização, suspendendo a execução quando estão pendentes. use(context) funciona condicionalmente, ao contrário de useContext. Sempre associe-o a Suspense para o carregamento e a ErrorBoundary para os erros.

A seguir

Próxima lição: **Ações do React e useActionState** — você definirá ações do servidor e do cliente e tratará envios de formulários com estado pendente.

Perguntas Frequentes

A aula “O hook use() para recursos assíncronos” é grátis?

Sim — o texto completo de “O hook use() para recursos assíncronos” é 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 “O hook use() para recursos assíncronos”?

Leia promessas e contextos durante a renderização com o hook use() no React 19. 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 “O hook use() para recursos assíncronos”?

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. Componentes de servidor do React explicados
  2. O hook use() para recursos assíncronos
  3. Ações do React e useActionState
  4. useOptimistic para feedback instantâneo
← Voltar para React Academy