Rotas e requisições

Crie telas acessíveis pela URL com React Router e busque dados com carregando, erro, vazio e proteção contra respostas fora de ordem.

Cerca de 16 min · Revisado em

Ao final, você vai conseguir

  • Explicar como um roteador troca de tela numa SPA sem recarregar a página
  • Declarar rotas com parâmetros, navegar com Link e ler valores com useParams
  • Buscar dados num efeito tratando carregando, erro e lista vazia
  • Evitar condições de corrida com a limpeza do efeito e AbortController
  • Decidir quando adotar uma biblioteca de dados como TanStack Query

No app do banco, você vai do extrato para a área Pix e volta, e a tela troca sem aquela piscada de página nova. Você pode mandar o link de um produto para alguém no grupo da família e a pessoa cai direto nele. E, quando a internet do ônibus oscila, um app bem-feito mostra “carregando” e “tente de novo” em vez de ficar em branco. Nesta aula você junta rotas e dados do servidor, o par que transforma componentes soltos numa aplicação.

Uma aplicação, várias telas

Num site tradicional, cada clique num link pede uma página HTML nova ao servidor, e o navegador joga fora a anterior. Uma SPA (sigla em inglês para aplicação de página única) carrega uma vez só e, a partir daí, o próprio JavaScript troca os componentes na tela quando a URL muda.

Quem decide qual componente aparecer para cada endereço é o roteador. Ele faz duas coisas: lê a URL atual e escolhe a tela, e intercepta os cliques nos links para trocar a URL sem recarregar. A URL continua importante: é ela que permite favoritar, compartilhar e usar o botão voltar.

O que acontece ao clicar num link dentro de uma SPA

  1. Pessoa → Roteador: Clica em “Camiseta”. O link aponta para /produtos/2. O roteador intercepta o clique antes de o navegador pedir uma página nova.
  2. Roteador → Roteador: Troca a URL. Ele muda o endereço com a History API do navegador. A barra mostra /produtos/2 e o botão voltar passa a funcionar, sem recarregar nada.
  3. Roteador → Componentes: Mostra DetalheProduto. O roteador compara a URL com as rotas declaradas e renderiza o componente da rota /produtos/:id, entregando id = 2.
  4. Componentes → Servidor: GET /api/produtos/2. O HTML não é pedido de novo. Só os dados do produto vão e voltam, normalmente em JSON.
  5. Servidor → Componentes: 200 + JSON. Com os dados, o componente sai do “carregando” e mostra o produto.

Numa SPA, você está em /produtos/2 e aperta F5. A página mostra “Cannot GET /produtos/2” só no servidor de produção. O que provavelmente aconteceu?

  • O servidor procurou um arquivo chamado /produtos/2 em vez de devolver o index.html da SPA para qualquer caminho
  • O React Router apagou a rota ao recarregar
  • Links de SPA não podem ser abertos diretamente

Rotas com React Router

O React não vem com roteador. A biblioteca mais usada é o React Router. Nas versões atuais ela é instalada com o nome react-router; em projetos mais antigos você vai ver react-router-dom, com os mesmos componentes.

Instalando o roteador num projeto Vite

Você está na pasta de um projeto React criado com Vite. Instale o roteador e suba o servidor de desenvolvimento.

  1. Instale o pacote do React Router com o npm

    npm install react-router
    
    added 3 packages, and audited 215 packages in 2s
    
    found 0 vulnerabilities
  2. Confira que ele entrou nas dependências do package.json

    grep react-router package.json
        "react-router": "^7.9.1",
  3. Rode o servidor de desenvolvimento

    npm run dev
    
      VITE v6.3.5  ready in 412 ms
    
      ➜  Local:   http://localhost:5173/
      ➜  press h + enter to show help

As três peças: declarar rotas, criar links e ler parâmetros

main.jsx

import { BrowserRouter, Routes, Route } from 'react-router';

createRoot(document.getElementById('root')).render(
  <BrowserRouter>
    <Routes>
      <Route path="/" element={<Inicio />} />
      <Route path="/produtos/:id" element={<DetalheProduto />} />
      <Route path="*" element={<NaoEncontrada />} />
    </Routes>
  </BrowserRouter>
);

Menu.jsx

import { Link } from 'react-router';

function Menu() {
  return (
    <nav>
      <Link to="/">Início</Link>
      <Link to="/produtos/2">Camiseta</Link>
    </nav>
  );
}

DetalheProduto.jsx

import { useParams } from 'react-router';

function DetalheProduto() {
  const { id } = useParams(); // em /produtos/2, id vale "2"
  return <h1>Produto {id}</h1>;
}

Uma rota com parâmetro.

<Route path="/produtos/:id" element={<DetalheProduto />} />
<Route path="*" element={<NaoEncontrada />} />
  • Parte fixa: Precisa aparecer igualzinha na URL para a rota combinar.
  • Parâmetro: Os dois-pontos dizem “aqui vale qualquer valor”. Em /produtos/42, useParams() devolve { id: "42" }. Repare que vem como texto: converta com Number(id) se for comparar com números.
  • O que mostrar: O componente renderizado quando a rota combina. Ele lê o parâmetro com useParams.
  • Qualquer outra: O asterisco combina com qualquer caminho que nenhuma outra rota pegou. É onde fica a página de não encontrado.

Dentro da SPA, um colega usou <a href="/produtos/2"> em vez de <Link to="/produtos/2">. O link funciona, mas o que se perde?

  • A página recarrega inteira: o navegador pede tudo de novo ao servidor e o estado da aplicação, como o carrinho em memória, é perdido
  • O endereço não muda na barra do navegador
  • Nada: <a> e Link são exatamente iguais

Complete a rota de detalhe de pedido e o componente que lê o número do pedido.

<Route path="/pedidos/____" element={<Pedido />} />

function Pedido() {
  const { numero } = ____();
  return <h1>Pedido {numero}</h1>;
}

Construa um mini roteador

O React Router não roda nos exercícios desta página, mas a ideia dele cabe em poucas linhas, e construir a sua versão é o melhor jeito de entender. O caminho atual vira um estado; o Link muda esse estado no clique; e uma função escolhe a tela comparando o caminho com padrões. O React Router tem até um modo assim, o MemoryRouter, usado em testes.

Catálogo com rotas

Complete o roteador. Para caminhos como /produtos/2, mostre DetalheProduto com um <h1> com o nome, o preço e um Link Voltar para /. Para qualquer outro caminho, inclusive um id que não existe, mostre Página não encontrada. Dica: caminho.match(/^\/produtos\/(\d+)$/) devolve o id na posição 1.

<div id="root"></div>
body { font-family: system-ui, sans-serif; margin: 16px; }
nav { display: flex; gap: 12px; }
.endereco { font-family: monospace; background: #f1f5f9; padding: 4px 8px; display: inline-block; }
a { color: #1d4ed8; }
const { useState } = React;

const produtos = [
  { id: 1, nome: 'Caneca', preco: 39 },
  { id: 2, nome: 'Camiseta', preco: 59 },
  { id: 3, nome: 'Boné', preco: 45 },
];

function Link({ para, navegar, children }) {
  return (
    <a
      href={'#' + para}
      onClick={(evento) => {
        evento.preventDefault();
        navegar(para);
      }}
    >
      {children}
    </a>
  );
}

function Inicio({ navegar }) {
  return (
    <>
      <h1>Produtos</h1>
      <ul>
        {produtos.map((produto) => (
          <li key={produto.id}>
            <Link para={'/produtos/' + produto.id} navegar={navegar}>{produto.nome}</Link>
          </li>
        ))}
      </ul>
    </>
  );
}

// TODO 1: crie DetalheProduto({ id, navegar }) com <h1> do nome,
// o preço e <Link para="/" navegar={navegar}>Voltar</Link>

// TODO 2: crie NaoEncontrada, com o texto "Página não encontrada"

function App() {
  const [caminho, setCaminho] = useState('/');

  function telaAtual() {
    if (caminho === '/') return <Inicio navegar={setCaminho} />;
    // TODO 3: se o caminho for /produtos/<número>, mostre DetalheProduto
    // TODO 4: para qualquer outro caminho, mostre NaoEncontrada
    return null;
  }

  return (
    <div>
      <nav>
        <Link para="/" navegar={setCaminho}>Início</Link>
        <Link para="/sobre" navegar={setCaminho}>Sobre</Link>
      </nav>
      <p className="endereco">{caminho}</p>
      {telaAtual()}
    </div>
  );
}

ReactDOM.createRoot(document.getElementById('root')).render(<App />);
  • Clicar em Camiseta abre a tela de detalhe com o nome e o preço
  • Voltar leva de volta para a lista de produtos
  • Um caminho que não existe mostra Página não encontrada
No mini roteador, o caminho mora só num estado. O que ele ainda não faz que o React Router com BrowserRouter faz?

Ele não muda a barra de endereço do navegador, então não dá para favoritar, compartilhar o link nem usar o botão voltar. O BrowserRouter guarda o caminho na própria URL com a History API (history.pushState) e escuta o evento popstate para reagir ao voltar e avançar. A lógica de combinar caminhos com padrões é a mesma que você escreveu.

Buscar dados quando a tela abre

Na aula de JavaScript assíncrono você viu os quatro estados de uma tela com dados: carregando, sucesso, vazio e erro. Em React eles viram estados do componente, e a busca vira um efeito: abrir a tela de detalhe é “sincronizar a tela com o servidor para este id”.

O formato básico: um efeito que depende do id e três estados

function DetalheProduto() {
  const { id } = useParams();
  const [produto, setProduto] = useState(null);
  const [carregando, setCarregando] = useState(true);
  const [erro, setErro] = useState(null);

  useEffect(() => {
    setCarregando(true);
    setErro(null);
    buscarProduto(id)
      .then((dados) => setProduto(dados))
      .catch((e) => setErro(e.message))
      .finally(() => setCarregando(false));
  }, [id]);

  if (carregando) return <p>Carregando...</p>;
  if (erro) return <p role="alert">{erro}</p>;
  return <h1>{produto.nome}</h1>;
}

Pedidos por cliente

Crie os estados carregando e erro. No efeito, ligue o carregando antes de buscar, trate a falha com .catch e desligue o carregando no .finally. Na tela, mostre Carregando... durante a busca; o erro num elemento com role="alert", sem a lista; e Nenhum pedido ainda. quando a lista vier vazia.

<div id="root"></div>
body { font-family: system-ui, sans-serif; margin: 16px; }
button { margin-right: 6px; padding: 4px 12px; cursor: pointer; }
[role="alert"] { color: #991b1b; background: #fee2e2; padding: 8px; border-radius: 6px; }
const { useState, useEffect } = React;

const banco = {
  Ana: ['Pão francês', 'Café'],
  Bruno: ['Coxinha', 'Suco de laranja', 'Pudim'],
  Carla: [],
};

// Uma API falsa: responde em 400 ms e falha para clientes desconhecidos.
function buscarPedidos(cliente) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (cliente in banco) resolve(banco[cliente]);
      else reject(new Error('Servidor fora do ar. Tente de novo.'));
    }, 400);
  });
}

function Pedidos() {
  const [cliente, setCliente] = useState('Ana');
  const [pedidos, setPedidos] = useState([]);
  // TODO 1: crie os estados carregando e erro

  useEffect(() => {
    // TODO 2: antes de buscar, ligue o carregando e limpe o erro
    buscarPedidos(cliente).then((lista) => {
      setPedidos(lista);
    });
    // TODO 3: trate a falha com .catch e desligue o carregando com .finally
  }, [cliente]);

  return (
    <div>
      {['Ana', 'Bruno', 'Carla', 'Davi'].map((nome) => (
        <button key={nome} onClick={() => setCliente(nome)}>{nome}</button>
      ))}
      <h2>Pedidos de {cliente}</h2>
      {/* TODO 4: Carregando..., erro com role="alert" ou Nenhum pedido ainda. */}
      <ul id="pedidos">
        {pedidos.map((pedido) => <li key={pedido}>{pedido}</li>)}
      </ul>
    </div>
  );
}

ReactDOM.createRoot(document.getElementById('root')).render(<Pedidos />);
  • Enquanto espera, aparece Carregando; depois, os 3 pedidos de Bruno
  • Carla, sem pedidos, vê Nenhum pedido ainda.
  • Se o servidor falha, aparece um aviso com role="alert" e a lista antiga some

A pessoa abre /produtos/7. Coloque em ordem o que acontece num componente bem-feito.

  • O roteador renderiza DetalheProduto com o parâmetro id igual a "7"
  • A primeira renderização mostra “Carregando...”
  • Depois da renderização, o efeito chama a API com o id 7
  • A resposta chega e o efeito guarda o produto no estado
  • O componente renderiza de novo, agora com o produto na tela

Respostas fora de ordem

Pedidos de rede não chegam na ordem em que saíram. Se a pessoa clica em Ana e logo depois em Bruno, e o servidor demora mais para responder Ana, a resposta de Ana chega por último e sobrescreve a de Bruno. A tela diz “Bruno” no título e mostra os dados de Ana. Isso se chama condição de corrida.

Duas buscas disputando a mesma tela

  1. Pessoa → Componente: Clica em Ana. O estado muda para Ana e o efeito dispara a primeira busca.
  2. Componente → Servidor: Busca Ana (lenta). Essa resposta vai demorar quase um segundo.
  3. Pessoa → Componente: Clica em Bruno. Logo depois, a pessoa muda de ideia. O efeito dispara a segunda busca.
  4. Componente → Servidor: Busca Bruno (rápida). Essa volta em poucos milissegundos.
  5. Servidor → Componente: Chega Bruno. A tela mostra Bruno. Até aqui, tudo certo.
  6. Servidor → Componente: Chega Ana, atrasada. Sem proteção, o .then antigo ainda roda e troca os dados para Ana, embora a pessoa tenha escolhido Bruno.

A correção usa a limpeza do efeito, que você conheceu na aula anterior. Quando o cliente muda, o React limpa o efeito antigo antes de rodar o novo. Se a limpeza marcar “ignore a resposta antiga”, a resposta atrasada chega e é descartada.

Ignorar a resposta atrasada

Clique em Ana e logo depois em Bruno: a tela termina mostrando Ana. Dentro do efeito, crie let ignorar = false, só chame setPerfil se ignorar for falso e devolva uma limpeza que faz ignorar = true.

<div id="root"></div>
body { font-family: system-ui, sans-serif; margin: 16px; }
button { margin-right: 6px; padding: 4px 12px; cursor: pointer; }
const { useState, useEffect } = React;

const cidades = { Ana: 'Recife', Bruno: 'Porto Alegre', Carla: 'Belém' };
const atrasos = { Ana: 900, Bruno: 150, Carla: 300 };

function buscarPerfil(nome) {
  return new Promise((resolve) => {
    setTimeout(() => resolve({ nome, cidade: cidades[nome] }), atrasos[nome]);
  });
}

function Perfil() {
  const [escolhido, setEscolhido] = useState('Carla');
  const [perfil, setPerfil] = useState(null);

  useEffect(() => {
    setPerfil(null);
    buscarPerfil(escolhido).then((dados) => {
      setPerfil(dados);
    });
    // TODO: ignore respostas que chegarem depois que escolhido mudar
  }, [escolhido]);

  return (
    <div>
      {['Ana', 'Bruno', 'Carla'].map((nome) => (
        <button key={nome} onClick={() => setEscolhido(nome)}>{nome}</button>
      ))}
      <p>Você escolheu: {escolhido}</p>
      <h2 id="perfil">{perfil ? perfil.nome + ', de ' + perfil.cidade : 'Carregando...'}</h2>
    </div>
  );
}

ReactDOM.createRoot(document.getElementById('root')).render(<Perfil />);
  • Clicar em Ana e logo depois em Bruno termina mostrando Bruno
  • Escolher uma pessoa só continua funcionando

Com fetch de verdade, dá para cancelar o pedido, não só ignorar a resposta.

useEffect(() => {
  const controle = new AbortController();
  fetch(`/api/perfis/${id}`, { signal: controle.signal })
    .then((resposta) => resposta.json())
    .then(setPerfil)
    .catch((erro) => {
      if (erro.name !== 'AbortError') setErro(erro.message);
    });
  return () => controle.abort();
}, [id]);
  • O controle remoto: AbortController é do próprio navegador. Ele cria um sinal que pode ser disparado para cancelar operações.
  • Ligar o sinal: O fetch passa a escutar esse sinal. Se ele for disparado, a requisição é interrompida, inclusive no painel Network, onde aparece como cancelada.
  • Cancelamento não é erro: Cancelar faz a Promise rejeitar com um erro chamado AbortError. Ele é esperado, então não deve virar mensagem de erro na tela.
  • Cancelar na limpeza: Quando o id muda ou a tela fecha, o pedido antigo é cancelado. Economiza dados móveis da pessoa e trabalho do servidor.

Por que o ignorar = true dentro da limpeza resolve a corrida, se a busca antiga continua acontecendo?

  • Porque cada execução do efeito tem sua própria variável ignorar; a limpeza marca a da execução antiga, e o .then antigo vê esse valor
  • Porque o React cancela as Promises automaticamente quando a dependência muda
  • Porque let faz a variável ser compartilhada entre todas as execuções do efeito

Quando usar uma biblioteca de dados

Você acabou de escrever, à mão, carregando, erro, vazio e proteção contra corrida. Numa aplicação com dezenas de telas, ainda aparecem novas necessidades: guardar respostas em cache (uma cópia local para não pedir de novo), tentar outra vez quando falha, atualizar quando a pessoa volta para a aba.

Bibliotecas como TanStack Query (antes chamada React Query) e SWR cuidam disso. O próprio React Router também pode carregar dados antes de mostrar a rota, com os loaders. A recomendação da trilha: comece com fetch e efeito para entender o problema, e adote uma biblioteca quando a repetição aparecer.

A mesma tela com efeito à mão e com TanStack Query

Efeito à mão

const [dados, setDados] = useState(null);
const [carregando, setCarregando] = useState(true);
const [erro, setErro] = useState(null);

useEffect(() => {
  let ignorar = false;
  setCarregando(true);
  buscarPedidos(cliente)
    .then((lista) => { if (!ignorar) setDados(lista); })
    .catch((e) => { if (!ignorar) setErro(e); })
    .finally(() => { if (!ignorar) setCarregando(false); });
  return () => { ignorar = true; };
}, [cliente]);

TanStack Query

import { useQuery } from '@tanstack/react-query';

const { data: dados, isPending: carregando, error: erro } = useQuery({
  queryKey: ['pedidos', cliente],
  queryFn: () => buscarPedidos(cliente),
});
// Corrida, cache, nova tentativa e atualização ao voltar
// para a aba já vêm resolvidos.

Quem resolve cada necessidade, com menos código?

React Router · Efeito com fetch basta · Biblioteca de dados

  • Ler o id do produto a partir da URL
  • Mostrar uma página de não encontrado para caminhos desconhecidos
  • Uma única tela que busca uma lista uma vez ao abrir
  • Ignorar a resposta antiga ao trocar de cliente numa tela simples
  • Não pedir de novo os dados de uma tela que a pessoa visitou há 10 segundos
  • Atualizar os dados sozinho quando a pessoa volta para a aba

Fechamento

  • Numa SPA, o roteador lê a URL, escolhe o componente e intercepta os links para trocar de tela sem recarregar.
  • No React Router, Route declara caminhos como /produtos/:id, Link navega e useParams lê os parâmetros, que chegam como texto.
  • Buscar dados é um efeito que depende do parâmetro, com estados de carregando, erro e vazio, como os quatro estados da aula de JavaScript assíncrono.
  • Respostas podem chegar fora de ordem: use a limpeza do efeito para ignorar respostas antigas ou um AbortController para cancelar o fetch.
  • Bibliotecas como TanStack Query trazem cache e novas tentativas; adote quando a repetição de código de busca aparecer.

Tela de detalhe pela URL

No seu projeto React com Vite, crie uma lista e uma tela de detalhe acessível pela URL, com dados vindos de uma API pública ou de um arquivo JSON servido pelo próprio Vite.

  1. Instale o React Router e crie as rotas /, /itens/:id e uma rota * de não encontrado
  2. Na tela de detalhe, leia o id com useParams e busque os dados num efeito que depende dele
  3. Mostre carregando, erro com botão de tentar de novo e uma mensagem para item inexistente
  4. Proteja a busca contra corrida com AbortController e confira no painel Network que pedidos antigos aparecem como cancelados
  5. Abra a tela de detalhe colando a URL numa aba nova e verifique que ela carrega direto

Referências

Cursos relacionados