Hook useReducer: Ações, Dispatch e Gerenciamento de Estados Complexos
📑 Índice do Conteúdo
Quando o useState Começa a Falhar: A Dor dos Múltiplos Estados Desconectados
Conforme suas aplicações em React ganham robustez e complexidade, o gerenciamento de estados locais exclusivamente através do useState pode se transformar em um pesadelo de manutenção. Considere um cenário clássico de um formulário de cadastro de múltiplos passos ou um carrinho de e-commerce:
// Fragmentação excessiva com múltiplos useState
const [items, setItems] = useState([]);
const [coupon, setCoupon] = useState(null);
const [discount, setDiscount] = useState(0);
const [shippingCost, setShippingCost] = useState(15);
const [isLoading, setIsLoading] = useState(false);
const [error, setError] = useState(null);
Nesse modelo, quando o usuário remove um item ou aplica um cupom, você precisa disparar 3 ou 4 atualizadores manuais (setItems, setDiscount, setShippingCost, etc.). Se algum desenvolvedor esquecer de sincronizar um desses setters em algum fluxo, a aplicação entra em um estado corrompido ou inconsistente.
É exatamente para resolver transições de estado complexas, interdependentes ou relacionais que o React fornece o poderoso hook useReducer.
Filosofia do useReducer: Em vez de espalhar lógicas de atualização de estado por dezenas de manipuladores de clique, você centraliza todas as regras de transição em uma única função pura (o Reducer), e seus componentes apenas despacham (dispatch) mensagens dizendo o que acabou de acontecer.
O Paradigma Reducer: Funções Puras e Transições Previsíveis
O conceito de Reducer é inspirado no método nativo Array.prototype.reduce() do JavaScript e consolidado na arquitetura Flux/Redux. Uma função reducer obedece rigorosamente à seguinte assinatura matemática:
(currentState, action) => newState
Regras fundamentais de ouro para qualquer função Reducer:
- Pureza Absoluta: Dados os mesmos parâmetros de entrada (estado atual e ação), a função DEVE obrigatoriamente retornar exatamente o mesmo novo estado.
- Sem Mutações Diretas: Você nunca deve alterar propriedades de
statediretamente (comostate.count++oustate.items.push()). Sempre utilize imutabilidade com spread operator ({ ...state, count: state.count + 1 }). - Zero Efeitos Colaterais: Um reducer jamais deve executar requisições
fetch(), alterar olocalStorage, iniciar timers ou gerar números aleatórios. O reducer é exclusivamente uma máquina de cálculo de estados.
Anatomia do Hook useReducer
O useReducer é importado diretamente do núcleo do React e possui a seguinte estrutura:
const [state, dispatch] = useReducer(reducer, initialState, init);
state: O valor atual do estado mantido pelo React para este componente.dispatch: A função despachante que você chama para enviar ações ao reducer. Garantia do React: a referência da funçãodispatché perfeitamente estável e nunca muda entre re-renders, sendo ideal para repassar via props para componentes filhos sem causar re-renderizações desnecessárias.reducer: A função pura que contém as regras de transição (geralmente estruturada com uma declaraçãoswitch/case).initialState: O estado inicial do componente.init(Opcional): Uma função para inicialização preguiçosa (Lazy Initialization), útil quando o estado inicial exige cálculos custosos ou leitura do DOM/Storage.
O Padrão Flux de Ações: type e payload
Por convenção da indústria (Flux Standard Action), toda ação enviada ao reducer é um objeto literal contendo duas propriedades essenciais:
type(string obrigatória): O identificador em maiúsculas (UPPERCASE) da intenção que ocorreu. Ex:'ADD_ITEM','DELETE_ITEM','SET_ERROR'.payload(dado opcional): Os dados complementares necessários para concretizar a transição de estado (o novo texto, o ID do item, o valor digitado).
Exemplo Prático Completo: Gerenciador de Tarefas com useReducer
Abaixo está a implementação corporativa completa de um gerenciador de tarefas com filtro de status, demonstrando imutabilidade e previsibilidade:
import React, { useReducer, useState } from 'react';
// 1. Estado Inicial
const initialState = {
tasks: [
{ id: 1, title: 'Dominar Hooks do React', completed: true },
{ id: 2, title: 'Aprender useReducer e Context API', completed: false }
],
filter: 'ALL' // ___WZW_STR_1___, ___WZW_STR_2___, ___WZW_STR_3___
};
// 2. Função Reducer Pura
function taskReducer(state, action) {
switch (action.type) {
case 'ADD_TASK': {
if (!action.payload.trim()) return state;
const newTask = {
id: Date.now(),
title: action.payload.trim(),
completed: false
};
return {
...state,
tasks: [newTask, ...state.tasks]
};
}
case 'TOGGLE_TASK': {
return {
...state,
tasks: state.tasks.map(task =>
task.id === action.payload
? { ...task, completed: !task.completed }
: task
)
};
}
case 'DELETE_TASK': {
return {
...state,
tasks: state.tasks.filter(task => task.id !== action.payload)
};
}
case 'SET_FILTER': {
return {
...state,
filter: action.payload
};
}
case 'CLEAR_COMPLETED': {
return {
...state,
tasks: state.tasks.filter(task => !task.completed)
};
}
default:
throw new Error(`Ação desconhecida recebida pelo taskReducer: ${action.type}`);
}
}
// 3. Componente da Interface
export default function TaskManager() {
const [state, dispatch] = useReducer(taskReducer, initialState);
const [inputVal, setInputVal] = useState('');
const handleAdd = (e) => {
e.preventDefault();
dispatch({ type: 'ADD_TASK', payload: inputVal });
setInputVal('');
};
const filteredTasks = state.tasks.filter(task => {
if (state.filter === 'COMPLETED') return task.completed;
if (state.filter === 'PENDING') return !task.completed;
return true;
});
return (
<div style={{ maxWidth: '480px', margin: '30px auto', fontFamily: 'sans-serif' }}>
<h3>Gerenciador de Tarefas com useReducer</h3>
<form onSubmit={handleAdd} style={{ display: 'flex', gap: '8px', marginBottom: '16px' }}>
<input
type="text"
value={inputVal}
onChange={(e) => setInputVal(e.target.value)}
placeholder="Nova tarefa..."
style={{ flex: 1, padding: '8px 12px', borderRadius: '6px', border: '1px solid #cbd5e1' }}
/>
<button type="submit" style={{ padding: '8px 16px', background: '#3b82f6', color: '#fff', border: 'none', borderRadius: '6px', cursor: 'pointer' }}>
Adicionar
</button>
</form>
<div style={{ display: 'flex', gap: '8px', marginBottom: '16px' }}>
{['ALL', 'PENDING', 'COMPLETED'].map(f => (
<button
key={f}
onClick={() => dispatch({ type: 'SET_FILTER', payload: f })}
style={{
padding: '4px 10px',
fontSize: '12px',
borderRadius: '4px',
border: '1px solid #94a3b8',
background: state.filter === f ? '#0f172a' : '#f8fafc',
color: state.filter === f ? '#fff' : '#0f172a',
cursor: 'pointer'
}}
>
{f === 'ALL' ? 'Todas' : f === 'PENDING' ? 'Pendentes' : 'Concluídas'}
</button>
))}
</div>
<ul style={{ listStyle: 'none', padding: 0 }}>
{filteredTasks.map(task => (
<li key={task.id} style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', padding: '8px', borderBottom: '1px solid #e2e8f0' }}>
<span
onClick={() => dispatch({ type: 'TOGGLE_TASK', payload: task.id })}
style={{
cursor: 'pointer',
textDecoration: task.completed ? 'line-through' : 'none',
color: task.completed ? '#94a3b8' : '#0f172a'
}}
>
{task.completed ? '✅ ' : '⭕ '} {task.title}
</span>
<button
onClick={() => dispatch({ type: 'DELETE_TASK', payload: task.id })}
style={{ background: '#ef4444', color: '#fff', border: 'none', borderRadius: '4px', padding: '4px 8px', cursor: 'pointer' }}
>
Excluir
</button>
</li>
))}
</ul>
<button
onClick={() => dispatch({ type: 'CLEAR_COMPLETED' })}
style={{ marginTop: '16px', background: 'transparent', border: '1px solid #cbd5e1', padding: '6px 12px', borderRadius: '4px', cursor: 'pointer', fontSize: '13px' }}
>
Limpar Concluídas
</button>
</div>
);
}
Inicialização Preguiçosa (Lazy Initialization com init)
Quando o estado inicial necessita de cálculos pesados ou deve ser recuperado do localStorage, você pode passar uma função inicializadora como terceiro parâmetro para evitar que essa computação seja reexecutada a cada re-render:
function initTasks(initialCount) {
const saved = localStorage.getItem('my_tasks');
if (saved) {
try {
return JSON.parse(saved);
} catch {
// fallback
}
}
return { tasks: [], filter: 'ALL' };
}
// O React chama initTasks(0) apenas na montagem inicial!
const [state, dispatch] = useReducer(taskReducer, 0, initTasks);
Aplique o que você aprendeu nesta lição
Utilize nossas ferramentas online gratuitas para experimentar os conceitos ou teste o código ao vivo no Playground IDE.
Editor de Códigos Web Online
Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.
Abrir Ferramenta OnlinePlayground Web Online
Escreva seu código HTML, CSS ou JavaScript e veja o resultado renderizado ao vivo no navegador com zero configuração.
⚡ Codificar no Playground IDE