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. Oswitchescolhe a regra certa para cada tipo. - Próximo estado: Um objeto novo. O
...estadocopia 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);- Linha 11: O estado inicial: nenhuma senha chamada, guichê 1. No React, este é o segundo argumento de
useReducer. - Linha 2: A primeira ação chega. O
switcholha o tipo:chamar. - Linha 4: O reducer monta um objeto novo: copia tudo com
...estadoe soma 1 na senha. O guichê veio junto, sem ninguém precisar lembrar dele. - Linha 12: O resultado vira o estado atual. No React, é aqui que a tela seria renderizada de novo.
- Linha 13: Mesma ação, mesma regra, resultado previsível.
- Linha 6: A ação
zerarcai em outrocase. Se chegasse um tipo desconhecido, odefaultdevolveria o estado sem mudança. - Linha 14: A senha voltou a zero, o guichê continua 1.
- 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.
Rode só os testes do arquivo
carrinhoReducercom o Vitest.npx vitest run carrinhoReducerRUN 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)O teste diz que o estado antigo ganhou um item. Mostre o conteúdo de
src/carrinho/carrinhoReducer.jspara achar o motivo.cat src/carrinho/carrinhoReducer.jsexport function carrinhoReducer(estado, acao) { switch (acao.type) { case 'adicionar': estado.push(acao.produto); return estado; default: return estado; } }Achou: o
pushaltera o array recebido. Você trocou as duas linhas porreturn [...estado, acao.produto];no editor. Rode os testes de novo.npx vitest run carrinhoReducerRUN 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
valuemuda, quem usauseContextrenderiza 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
- Vitrine → Reducer: dispatch({ type: 'adicionar' }). A vitrine pega o
dispatchdo contexto e envia a ação com o produto. Ela não sabe como o carrinho é guardado. - Reducer → Provider: Novo array de itens. O reducer calcula o próximo estado: uma cópia com o produto a mais.
- Provider → Cabeçalho: value muda. O Provider publica o novo estado. Quem lê o contexto renderiza de novo.
- 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
#contadorsubir 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
dispatchcom 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
useReducerquando 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,ProvidercomvalueeuseContext. - 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.
- Escreva um
carrinhoReducercom as ações adicionar, remover, mudar quantidade e esvaziar - Escreva testes do reducer com Vitest, incluindo um que garanta que o estado anterior não é alterado
- Crie um
CarrinhoProvidercom o reducer e mostre a quantidade de itens no cabeçalho usandouseContext - Liste no README cada estado da aplicação e explique por que ele é local, compartilhado ou dado do servidor