Reducer e Context

Organize estados que mudam juntos com useReducer e compartilhe valores distantes com Context, sem exagerar.

Cerca de 16 min · Revisado em

Ao final, você vai conseguir

  • Reconhecer quando vários useState devem virar um useReducer
  • Escrever um reducer puro que trata ações e testá-lo sem renderizar
  • Compartilhar um valor com createContext, Provider e useContext para evitar prop drilling
  • Decidir se um estado deve ser local, compartilhado por Context ou tratado como dado do servidor
  • Combinar reducer e Context para montar um carrinho de compras

Um carrinho de compras parece simples até você listar tudo o que ele faz: adicionar, remover, mudar quantidade, aplicar cupom, esvaziar. E o número de itens precisa aparecer no topo da página, longe da lista de produtos. Com useState espalhado e props passando de mão em mão, isso vira um emaranhado rápido. Nesta aula você vai aprender as duas ferramentas que o React oferece para organizar esse tipo de estado, e quando é melhor não usá-las.

Quando o useState começa a embolar

Na aula de estado e eventos você usou useState para guardar um valor de cada vez. Isso é ótimo enquanto cada valor muda sozinho. O problema aparece quando vários valores precisam mudar juntos, e cada clique tem que lembrar de atualizar todos eles.

Quatro estados que deveriam andar juntos, atualizados em lugares diferentes

const [itens, setItens] = useState([]);
const [total, setTotal] = useState(0);
const [cupom, setCupom] = useState(null);
const [carregando, setCarregando] = useState(false);

function adicionar(produto) {
  setItens([...itens, produto]);
  setTotal(total + produto.preco);
  // esqueceu de recalcular o desconto do cupom
}

Repare nos sinais de alerta: estados que dependem uns dos outros, regras repetidas em vários manipuladores de evento e combinações impossíveis, como carregando e erro verdadeiros ao mesmo tempo. Quando isso acontece, vale juntar a lógica em um lugar só.

Qual destes componentes é o melhor candidato para trocar vários useState por uma lógica centralizada?

  • Um botão de curtir que alterna entre curtido e não curtido
  • Um formulário de checkout com itens, cupom, frete e etapas que mudam juntos
  • Um campo de busca que guarda o texto digitado

useReducer: fichas de pedido e uma função que decide

Com useReducer, o componente deixa de dizer como mudar o estado e passa a dizer o que aconteceu. Ele envia uma ação, um objeto como { type: 'adicionar', produto }. Uma função chamada reducer recebe o estado atual e a ação, e devolve o próximo estado.

As peças do useReducer.

function filaReducer(estado, acao) {
  switch (acao.type) {
    case 'chamar':
      return { ...estado, senha: estado.senha + 1 };
    default:
      return estado;
  }
}

const [fila, dispatch] = useReducer(filaReducer, { senha: 0, guiche: 1 });

dispatch({ type: 'chamar' });
  • Reducer: Uma função comum, fora do componente. Recebe o estado atual e a ação e devolve o próximo estado. Ela não clica em nada nem busca dados: só calcula.
  • Tipo da ação: O nome do que aconteceu, escrito como um fato: chamar, adicionar, esvaziar. O switch escolhe a regra certa para cada tipo.
  • Próximo estado: Um objeto novo. O ...estado copia o que não mudou e a senha recebe o valor novo. O estado antigo fica intacto.
  • Enviar ação: A função que entrega uma ação ao reducer. Depois que ele devolve o novo estado, o React renderiza o componente de novo.
  • Estado inicial: O valor da primeira renderização, como o argumento de useState.
  • Ação: O componente só conta o que aconteceu. Quem decide o efeito disso no estado é o reducer.

Acompanhe as ações passando pelo reducer, como as senhas chamadas no posto de saúde.

function filaReducer(estado, acao) {
  switch (acao.type) {
    case 'chamar':
      return { ...estado, senha: estado.senha + 1 };
    case 'zerar':
      return { ...estado, senha: 0 };
    default:
      return estado;
  }
}
let fila = { senha: 0, guiche: 1 };
fila = filaReducer(fila, { type: 'chamar' });
fila = filaReducer(fila, { type: 'chamar' });
fila = filaReducer(fila, { type: 'zerar' });
console.log(fila.senha, fila.guiche);
  1. Linha 11: O estado inicial: nenhuma senha chamada, guichê 1. No React, este é o segundo argumento de useReducer.
  2. Linha 2: A primeira ação chega. O switch olha o tipo: chamar.
  3. Linha 4: O reducer monta um objeto novo: copia tudo com ...estado e soma 1 na senha. O guichê veio junto, sem ninguém precisar lembrar dele.
  4. Linha 12: O resultado vira o estado atual. No React, é aqui que a tela seria renderizada de novo.
  5. Linha 13: Mesma ação, mesma regra, resultado previsível.
  6. Linha 6: A ação zerar cai em outro case. Se chegasse um tipo desconhecido, o default devolveria o estado sem mudança.
  7. Linha 14: A senha voltou a zero, o guichê continua 1.
  8. Linha 15: Toda a história do estado pode ser recontada a partir da lista de ações. Isso facilita muito depurar. Saída: 0 1

Placar do jogo da várzea

Os botões já enviam as ações. Falta o reducer saber tratá-las: crie os casos ponto_visitante (soma 1 no visitante) e zerar (volta os dois para 0). Clique nos botões e veja o placar mudar.

<div id="root"></div>
body { font-family: system-ui, sans-serif; margin: 16px; }
.placar { font-size: 1.4rem; }
button { margin-right: 8px; padding: 6px 12px; cursor: pointer; }
const { useReducer } = React;

const inicial = { casa: 0, visitante: 0 };

function placarReducer(estado, acao) {
  switch (acao.type) {
    case 'ponto_casa':
      return { ...estado, casa: estado.casa + 1 };
    // crie aqui os casos 'ponto_visitante' e 'zerar'
    default:
      return estado;
  }
}

function Placar() {
  const [placar, dispatch] = useReducer(placarReducer, inicial);
  return (
    <div>
      <p className="placar">
        Casa <strong id="casa">{placar.casa}</strong> x <strong id="visitante">{placar.visitante}</strong> Visitante
      </p>
      <button onClick={() => dispatch({ type: 'ponto_casa' })}>Ponto Casa</button>
      <button onClick={() => dispatch({ type: 'ponto_visitante' })}>Ponto Visitante</button>
      <button onClick={() => dispatch({ type: 'zerar' })}>Zerar</button>
    </div>
  );
}

ReactDOM.createRoot(document.getElementById('root')).render(<Placar />);
  • Dois cliques em Ponto Visitante somam 2 ao visitante
  • Zerar volta os dois times para 0
  • Ponto Casa continua funcionando

O reducer é uma função pura

Uma função pura sempre devolve o mesmo resultado para as mesmas entradas e não mexe em nada fora dela. Dado o placar 2 x 1 e a ação ponto_casa, a resposta é sempre 3 x 1. É essa previsibilidade que torna o reducer fácil de entender e de testar.

Cada linha abaixo está dentro de um reducer. Pode ficar lá ou deveria sair?

Pode ficar no reducer · Deve sair do reducer

  • return { ...estado, senha: estado.senha + 1 };
  • return estado.filter((item) => item.id !== acao.id);
  • return [...estado, acao.produto];
  • estado.itens.push(acao.produto); return estado;
  • fetch('/api/carrinho', { method: 'POST' });
  • return { ...estado, id: Math.random() };

Como o reducer é só uma função, você testa sem renderizar nada: chama com um estado e uma ação e confere o retorno. Na aula de testes você usou o Vitest com a tela; aqui ele fica ainda mais simples.

Um teste pegando uma mutação

O carrinho às vezes mostra itens “fantasmas”. Rode os testes do reducer e leia a falha.

  1. Rode só os testes do arquivo carrinhoReducer com o Vitest.

    npx vitest run carrinhoReducer
     RUN  v2.1.8 /home/voce/padaria
    
     ❯ src/carrinho/carrinhoReducer.test.js (2 tests | 1 failed)
       ✓ adicionar coloca o produto no carrinho
       × adicionar não altera o estado anterior
         → expected [ { id: 1, nome: 'Pão de queijo' } ] to deeply equal []
    
     Test Files  1 failed (1)
          Tests  1 failed | 1 passed (2)
  2. O teste diz que o estado antigo ganhou um item. Mostre o conteúdo de src/carrinho/carrinhoReducer.js para achar o motivo.

    cat src/carrinho/carrinhoReducer.js
    export function carrinhoReducer(estado, acao) {
      switch (acao.type) {
        case 'adicionar':
          estado.push(acao.produto);
          return estado;
        default:
          return estado;
      }
    }
  3. Achou: o push altera o array recebido. Você trocou as duas linhas por return [...estado, acao.produto]; no editor. Rode os testes de novo.

    npx vitest run carrinhoReducer
     RUN  v2.1.8 /home/voce/padaria
    
     ✓ src/carrinho/carrinhoReducer.test.js (2 tests) 3ms
    
     Test Files  1 passed (1)
          Tests  2 passed (2)

Context: o fim do telefone sem fio de props

Outro problema, diferente do primeiro: um dado que muitos componentes distantes precisam, como o tema claro ou escuro, ou a pessoa que está logada. Passar esse valor por props de pai para filho, por componentes que nem usam, tem nome: prop drilling (perfurar com props).

O mesmo tema, antes e depois do Context

Prop drilling

function App() {
  const [tema, setTema] = useState('claro');
  return <Layout tema={tema} />;
}

function Layout({ tema }) {
  // Layout não usa tema, só repassa
  return <Cabecalho tema={tema} />;
}

function Cabecalho({ tema }) {
  return <BotaoMenu tema={tema} />;
}

function BotaoMenu({ tema }) {
  return <button className={tema}>Menu</button>;
}

Com Context

const TemaContext = createContext('claro');

function App() {
  const [tema, setTema] = useState('claro');
  return (
    <TemaContext.Provider value={tema}>
      <Layout />
    </TemaContext.Provider>
  );
}

function Layout() {
  return <Cabecalho />;
}

function Cabecalho() {
  return <BotaoMenu />;
}

function BotaoMenu() {
  const tema = useContext(TemaContext);
  return <button className={tema}>Menu</button>;
}
createContext
Cria o “quadro de avisos”. O argumento é o valor padrão, usado quando não existe nenhum Provider acima.
Provider
O componente que publica o valor com a prop value. Tudo o que estiver dentro dele, em qualquer profundidade, pode ler.
useContext
O hook que lê o valor do Provider mais próximo acima. Quando o value muda, quem usa useContext renderiza de novo.

Complete para que Avatar leia a pessoa logada sem receber props.

const UsuarioContext = ____(null);

function App() {
  const usuario = { nome: 'Dandara' };
  return (
    <UsuarioContext.____ value={usuario}>
      <Pagina />
    </UsuarioContext.Provider>
  );
}

function Avatar() {
  const usuario = ____(UsuarioContext);
  return <span>Olá, {usuario.nome}</span>;
}

O BotaoMenu usa useContext(TemaContext), mas está fora de qualquer TemaContext.Provider. O que ele recebe?

  • O valor padrão passado para createContext
  • Um erro que impede a página de abrir
  • O valor do Provider mais próximo em qualquer lugar da página

Quando o Context não é a resposta

Context resolve distância, não complexidade. E tem um custo: todo componente que lê um contexto renderiza de novo quando o valor muda. Um contexto gigante, com tudo do app, faz a página inteira se mexer a cada tecla digitada.

  • Prefira estado local. Se só um componente usa o valor, ele fica nesse componente.
  • Tente props primeiro. Passar por dois ou três níveis é normal e deixa claro de onde o dado vem.
  • Considere children. Às vezes o componente do meio pode receber o filho já pronto, e a prop deixa de atravessá-lo.
  • Separe dados do servidor. Lista de produtos vinda da API é cópia de algo que vive no backend; ela pede carregamento, erro e atualização. Guarde no componente que busca ou use uma biblioteca feita para isso, não um contexto genérico.

Onde cada estado deveria morar?

Estado local · Context · Dados do servidor

  • Se o menu sanfona está aberto
  • Texto digitado no campo de busca
  • Tema claro ou escuro escolhido
  • Pessoa logada e idioma da interface
  • Lista de produtos retornada pela API
  • Histórico de pedidos da conta

Uma colega colocou tudo do app num único AppContext: tema, usuário, carrinho e o texto da busca. O que tende a acontecer?

  • Nada de especial: Context foi feito para guardar o estado do app inteiro
  • Cada letra digitada na busca renderiza de novo todos os componentes que leem o contexto
  • A busca para de funcionar, porque Context só aceita valores que não mudam

Juntando os dois: um carrinho de compras

Agora os dois problemas aparecem juntos. O carrinho tem transições complexas (reducer) e precisa ser lido em lugares distantes (Context). A combinação é comum: o Provider guarda o useReducer e publica o estado e o dispatch.

Um clique em “Adicionar” atravessando o carrinho

  1. Vitrine → Reducer: dispatch({ type: 'adicionar' }). A vitrine pega o dispatch do contexto e envia a ação com o produto. Ela não sabe como o carrinho é guardado.
  2. Reducer → Provider: Novo array de itens. O reducer calcula o próximo estado: uma cópia com o produto a mais.
  3. Provider → Cabeçalho: value muda. O Provider publica o novo estado. Quem lê o contexto renderiza de novo.
  4. Cabeçalho → Cabeçalho: Mostra 1 item. O cabeçalho, do outro lado da página, mostra a quantidade e o total atualizados sem nenhuma prop.

O carrinho da padaria

A vitrine já adiciona produtos, mas o cabeçalho mostra números fixos. No Cabecalho, leia itens e dispatch com useContext, mostre a quantidade em #contador e a soma dos preços em #total. Depois crie a ação esvaziar no reducer e ligue o botão Esvaziar.

<div id="root"></div>
body { font-family: system-ui, sans-serif; margin: 16px; }
header { display: flex; gap: 8px; align-items: center; padding: 8px; background: #fef3c7; border-radius: 8px; }
li { margin: 6px 0; }
button { margin-left: 8px; padding: 4px 10px; cursor: pointer; }
const { createContext, useContext, useReducer } = React;

const produtos = [
  { id: 1, nome: 'Pão de queijo', preco: 6 },
  { id: 2, nome: 'Café coado', preco: 5 },
  { id: 3, nome: 'Bolo de fubá', preco: 8 },
];

function carrinhoReducer(estado, acao) {
  switch (acao.type) {
    case 'adicionar':
      return [...estado, acao.produto];
    // crie o caso 'esvaziar'
    default:
      return estado;
  }
}

const CarrinhoContext = createContext(null);

function CarrinhoProvider({ children }) {
  const [itens, dispatch] = useReducer(carrinhoReducer, []);
  return (
    <CarrinhoContext.Provider value={{ itens, dispatch }}>
      {children}
    </CarrinhoContext.Provider>
  );
}

function Cabecalho() {
  // leia o carrinho do contexto aqui
  return (
    <header>
      <span>Carrinho: <strong id="contador">0</strong> itens</span>
      <span>Total: <strong id="total">R$ 0</strong></span>
      <button>Esvaziar</button>
    </header>
  );
}

function Vitrine() {
  const { dispatch } = useContext(CarrinhoContext);
  return (
    <ul>
      {produtos.map((p) => (
        <li key={p.id}>
          {p.nome} (R$ {p.preco})
          <button onClick={() => dispatch({ type: 'adicionar', produto: p })}>Adicionar {p.nome}</button>
        </li>
      ))}
    </ul>
  );
}

function App() {
  return (
    <CarrinhoProvider>
      <Cabecalho />
      <Vitrine />
    </CarrinhoProvider>
  );
}

ReactDOM.createRoot(document.getElementById('root')).render(<App />);
  • Adicionar dois produtos faz #contador subir 2
  • Adicionar um bolo de fubá soma R$ 8 em #total
  • Esvaziar zera a quantidade e o total
No carrinho, o total não ficou guardado no estado: ele é calculado a partir dos itens a cada renderização. Por que isso é melhor do que ter um total no reducer?

Porque um valor que pode ser calculado a partir de outro nunca fica desatualizado. Se o total estivesse no estado, cada ação teria que lembrar de recalculá-lo, e um esquecimento faria a soma mentir. Guarde o mínimo e derive o resto.

Coloque em ordem o caminho de uma ação até a tela.

  • A pessoa clica em um botão
  • O componente chama dispatch com uma ação
  • O reducer recebe o estado atual e a ação
  • O reducer devolve um novo estado
  • O Provider publica o novo valor no contexto
  • Os componentes que leem o contexto renderizam de novo

Fechamento

  • Use useReducer quando vários valores mudam juntos: o componente envia ações e o reducer decide o próximo estado.
  • O reducer é uma função pura: não muta o estado recebido, não busca dados e não sorteia valores, o que o torna fácil de testar.
  • Context entrega um valor a componentes distantes sem prop drilling: createContext, Provider com value e useContext.
  • Estado local continua sendo o padrão; dados do servidor merecem tratamento próprio e contextos gigantes renderizam demais.
  • Reducer dentro de um Provider é a combinação clássica para estados como o carrinho de compras.

Monte o carrinho do seu projeto

Leve o carrinho para o projeto React que você vem construindo e documente as decisões. Explicar onde cada estado mora é tão importante quanto o código.

  1. Escreva um carrinhoReducer com as ações adicionar, remover, mudar quantidade e esvaziar
  2. Escreva testes do reducer com Vitest, incluindo um que garanta que o estado anterior não é alterado
  3. Crie um CarrinhoProvider com o reducer e mostre a quantidade de itens no cabeçalho usando useContext
  4. Liste no README cada estado da aplicação e explique por que ele é local, compartilhado ou dado do servidor

Referências

Cursos relacionados