useReducer no React: Ações, Dispatch e Estado
⚡ Curso de React.js • Web-ZoneWare

Hook useReducer: Ações, Dispatch e Gerenciamento de Estados Complexos

Lição 25 de 50

Hook useReducer: Ações, Dispatch e Gerenciamento de Estados Complexos

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:

CODE 7 linhas
// 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:

JavaScript 1 linha
(currentState, action) => newState

Regras fundamentais de ouro para qualquer função Reducer:

  1. 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.
  2. Sem Mutações Diretas: Você nunca deve alterar propriedades de state diretamente (como state.count++ ou state.items.push()). Sempre utilize imutabilidade com spread operator ({ ...state, count: state.count + 1 }).
  3. Zero Efeitos Colaterais: Um reducer jamais deve executar requisições fetch(), alterar o localStorage, 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:

JavaScript 1 linha
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ção dispatch é 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ção switch/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:

CODE 150 linhas
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:

JavaScript 14 linhas
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);
🛠️ Laboratório Prático & Prática Imediata

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.

💻 Desenvolvedor & Código

Editor de Códigos Web Online

Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.

Abrir Ferramenta Online
⚡ Live Code Studio

Playground 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
Foto de Web-Zoneware
✓ Verificado
🎓 Tutor & Coordenador da Web Academy

Web-Zoneware

Tutor Técnico & Desenvolvedor Full-Stack

Desenvolvedor web e instrutor focado na formação prática de novos programadores. Defensor ferrenho de código semântico, arquitetura limpa e acessibilidade W3C/WCAG, dedicando-se a construir cursos estruturados em metodologia passo a passo com execução ao vivo no Playground IDE.

Especialidades: HTML5 Semântico CSS3 & Flexbox/Grid JavaScript Moderno Acessibilidade WCAG 2.2 Didática Prática
Rolar para cima