Atualização Funcional com prevState no React: Fila de Estados e Stale Closures
📑 Índice do Conteúdo
1. A Dependência Frágil do Snapshot Estático
Na Lição 12, descobrimos que o estado no React se comporta como um snapshot (fotografia estática) do momento em que o componente foi renderizado. Quando você atualiza o estado passando um valor direto baseado na variável do escopo:
const [contador, setContador] = useState(0);
function incrementar() {
setContador(contador + 1); // Depende do valor capturado na closure atual!
}
Essa abordagem funciona perfeitamente para interações simples e espaçadas no tempo. No entanto, ela introduz vulnerabilidades críticas de sincronização e concorrência em dois cenários muito frequentes:
- Múltiplas atualizações dentro do mesmo ciclo de evento (ex: invocar o setter três vezes consecutivas na mesma função).
- Atualizações disparadas de forma assíncrona (ex: dentro de um
setTimeout,setInterval, requisição HTTP viafetchou listener de WebSocket), onde o estado pode ter mudado enquanto a operação assíncrona aguardava resposta.
Para solucionar essas limitações na raiz da arquitetura, o React permite que a função despachante (o setter) receba não apenas um valor direto, mas uma Função Atualizadora (Updater Function).
2. O Que é a Atualização Funcional (prevState)?
Uma Atualização Funcional ocorre quando você passa uma função de callback como argumento para o setter. Essa função recebe automaticamente o valor mais recente e pontual do estado na memória do React (convencionalmente chamado de prevState ou prev) e deve retornar o próximo valor calculado:
// ✅ ATUALIZAÇÃO FUNCIONAL: Segura contra qualquer concorrência!
setContador(prevContador => prevContador + 1);
// Ou na sintaxe concisa com arrow function:
setContador(prev => prev + 1);
A diferença essencial é que a sua função não depende mais de nenhuma variável capturada na closure do render atual. Ela terceiriza o cálculo para a própria fila interna do React.
3. Engenharia por Baixo dos Panos: A Fila de Atualizações (State Update Queue)
Para entender o motivo pelo qual a atualização funcional é 100% segura, precisamos analisar como o React gerencia o Update Queue no Fiber Node.
Relembre o experimento da aula anterior, onde tentamos somar 3 ao contador com três chamadas consecutivas:
// ❌ MODO DIRETO (Resulta apenas em +1):
function somarTresDireto() {
setContador(contador + 1); // Lê 0 -> agenda 1
setContador(contador + 1); // Lê 0 -> sobrescreve com 1
setContador(contador + 1); // Lê 0 -> sobrescreve com 1
}
// ✅ MODO FUNCIONAL (Resulta exatamente em +3):
function somarTresFuncional() {
setContador(prev => prev + 1);
setContador(prev => prev + 1);
setContador(prev => prev + 1);
}
Veja como o React processa a Fila de Atualizações (State Queue) durante o ciclo de Automatic Batching no modo funcional:
Processamento Sequencial da State Update Queue
• Estado Inicial na Memória: 0
• 1ª Função na Fila: (prev => prev + 1) → Recebe 0 → Retorna 1.
• 2ª Função na Fila: (prev => prev + 1) → Recebe 1 → Retorna 2.
• 3ª Função na Fila: (prev => prev + 1) → Recebe 2 → Retorna 3.
• Resultado Final Consolidado no Próximo Render: 3!
Mesmo que o React agrupe todas as três chamadas em um único re-render, cada função da fila recebe o resultado computado pela função anterior. A integridade matemática é absoluta.
4. O Bug Silencioso das Stale Closures (Closures Desatualizadas)
Um dos bugs mais devastadores em aplicações de produção ocorre quando combinamos useState com temporizadores (setTimeout/setInterval) ou requisições assíncronas.
Observe com atenção este componente:
function NotificadorAtrasado() {
const [mensagens, setMensagens] = useState(0);
function handleEnviarAtrasado() {
setTimeout(() => {
// 🚨 PERIGO: 'mensagens' foi congelado no momento do clique!
setMensagens(mensagens + 1);
}, 3000);
}
return (
<div>
<h2>Mensagens: {mensagens}</h2>
<button onClick={() => setMensagens(mensagens + 1)}>Mensagem Rápida (+1)</button>
<button onClick={handleEnviarAtrasado}>Enviar com Delay (3s)</button>
</div>
);
}
| Tempo | Ação do Usuário | Estado na UI | O Que Ocorre por Baixo dos Panos |
|---|---|---|---|
| 0s | Clica em “Enviar com Delay” | 0 |
O setTimeout captura a closure onde mensagens = 0. |
| 1s | Clica 5x em “Mensagem Rápida” | 5 |
O contador avança para 5 normalmente. |
| 3s | O setTimeout finalmente dispara |
1 (REBAIXADO!) | Executa setMensagens(0 + 1). Os 5 incrementos foram apagados da tela! |
Como resolver este problema definitivamente? Substituindo por atualização funcional:
setTimeout(() => {
// ✅ IMUNE À STALE CLOSURE: Lê o valor real no instante do disparo (5 + 1 = 6)!
setMensagens(prev => prev + 1);
}, 3000);
5. Matriz de Decisão Arquitetural: Quando Usar Cada Abordagem?
Use Valor Direto: setState(novoValor)
Quando o novo valor a ser gravado não depende de forma alguma do valor que estava lá antes:
- Inputs controlados de texto:
setNome(e.target.value) - Definição estática de status:
setCarregando(false) - Substituição de registros:
setUsuario(dadosDaApi)
Use Atualização Funcional: setState(prev => …)
Sempre que o próximo estado for derivado, calculado ou complementado a partir do estado anterior:
- Contadores matemáticos:
setCount(c => c + 1) - Inversão de booleanos (toggles):
setAberto(prev => !prev) - Inserções em arrays:
setLista(prev => [...prev, novoItem]) - Qualquer atualização dentro de
setTimeout,setIntervalou Promises
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