0Pricing
React Academy · Aula

Suspense para limites de dados e código

Combine Suspense com carregamento sob demanda e futuras bibliotecas de dados para criar estados de carregamento organizados.

Suspense para limites de dados e código é uma aula grátis de React Academy no CoddyKit. Esta é a aula 4 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á React Suspense com React.lazy para divisão de código e com bibliotecas de dados, mostrando uma interface alternativa enquanto o conteúdo é carregado.

O que é Suspense?

Suspense é um componente do React que captura componentes em sua subárvore que estão “suspensos” (aguardando algo ser carregado) e renderiza uma interface alternativa em seu lugar.
<Suspense fallback={<Spinner />}>
  <MyComponent />
</Suspense>

Suspense com React.lazy

React.lazy() cria um componente carregado a partir de uma importação dinâmica. Quando usado dentro de Suspense, a interface alternativa é renderizada até que o pacote de JavaScript seja baixado.
const HeavyChart = React.lazy(() => import('./HeavyChart'));

<Suspense fallback={<p>Loading chart...</p>}>
  <HeavyChart />
</Suspense>

Vários componentes lazy sob um único limite

Vários componentes lazy sob o mesmo limite de Suspense compartilham uma única interface alternativa. O React espera que ALL os componentes sejam carregados antes de mostrar o conteúdo. Use limites aninhados para carregamentos independentes.

Limites de Suspense aninhados

Aninhe limites de Suspense para mostrar partes da interface à medida que são carregadas, em vez de esperar por tudo. Os limites externos capturam carregamentos mais lentos; os internos cuidam dos carregamentos rápidos.
<Suspense fallback={<PageSkeleton />}>
  <Header />
  <Suspense fallback={<ChartSkeleton />}>
    <LazyChart />
  </Suspense>
</Suspense>

Suspense com bibliotecas de dados

Bibliotecas como React Query (com suspense: true) e Relay suspendem componentes que estão aguardando dados, assim como no carregamento tardio. O limite de Suspense fornece a interface alternativa de carregamento.
const { data } = useQuery({ queryKey: ['users'], queryFn: fetchUsers,
  suspense: true }); // component suspends until data is ready
// No loading check needed — data is always available here

Gancho use() no React 19

No React 19, o gancho `use(promise)` permite ler uma promessa diretamente em um componente. Se a promessa estiver pendente, o componente será suspenso e o limite de Suspense mais próximo exibirá sua interface alternativa.
import { use } from 'react';

function Profile({ userPromise }) {
  const user = use(userPromise); // suspends until resolved
  return <p>{user.name}</p>;
}

SuspenseList para exibições ordenadas

React.SuspenseList (experimental) coordena vários limites de Suspense para que sejam exibidos em uma ordem específica (de cima para baixo, todos de uma vez etc.) — evitando que a interface apareça de forma caótica.

Suspense não captura erros

Suspense lida apenas com estados de carregamento. Ele não captura erros de buscas que falharam. Combine Suspense com um limite de erros para lidar com estados de carregamento e de erro.
<ErrorBoundary fallback={<Error />}>
  <Suspense fallback={<Spinner />}>
    <DataComponent />
  </Suspense>
</ErrorBoundary>

Telas esqueletais como interfaces alternativas

Em vez de indicadores giratórios, use telas esqueletais como interfaces alternativas de Suspense. Telas esqueletais são layouts de espaço reservado que correspondem ao formato do conteúdo, reduzindo o deslocamento do layout quando o conteúdo chega.

Verificação rápida

O que é mostrado aos usuários enquanto o pacote de um componente React.lazy() está sendo baixado?

Recapitulação

Suspense envolve componentes em carregamento e mostra uma interface alternativa. Use React.lazy para divisão de código, os modos de Suspense das bibliotecas de dados para carregamento de dados e limites aninhados para exibições progressivas independentes. Combine-o com um limite de erros para obter um tratamento completo de erros.

Curso concluído

Parabéns! Você concluiu **Padrões assíncronos no React: Promessas e concorrência**. Agora você sabe lidar com condições de corrida, usar useTransition e useDeferredValue para criar interfaces responsivas e aproveitar Suspense para definir limites de carregamento.

Perguntas Frequentes

A aula “Suspense para limites de dados e código” é grátis?

Sim — o texto completo de “Suspense para limites de dados e código” é 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 “Suspense para limites de dados e código”?

Combine Suspense com carregamento sob demanda e futuras bibliotecas de dados para criar estados de carregamento organizados. 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 4 de 4.

Quanto tempo leva a aula “Suspense para limites de dados e código”?

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