Gerenciando Estados Complexos no React: Objetos, Arrays & Imutabilidade
📑 Índice do Conteúdo
1. A Comparação por Referência (Object.is) no React
No JavaScript, tipos primitivos (como números, textos e booleanos) são comparados por valor: se você tem 10 === 10, o resultado é verdadeiro. No entanto, estruturas de dados complexas como Objetos e Arrays são tipos de dados armazenados na memória heap e comparados exclusivamente por referência de memória (ponteiro de endereço):
const a = { id: 1 };
const b = { id: 1 };
console.log(a === b); // FALSE! São dois objetos diferentes na memória.
const c = a;
c.id = 99;
console.log(a === c); // TRUE! Ambos apontam para o mesmo endereço de memória.
Quando você invoca a função despachante do useState, o motor interno do React executa o algoritmo Object.is(novoEstado, estadoAnterior) para verificar se houve alteração real. Se o resultado for verdadeiro (ou seja, se o ponteiro de memória não mudou), o React conclui que nada foi alterado e cancela imediatamente o re-render (bailout) para economizar processamento!
2. O Erro Fatal: Mutação Direta de Estado
O maior erro cometido por desenvolvedores ao lidar com objetos é modificar as propriedades diretamente antes de chamar o setter:
// ❌ NUNCA FAÇA ISSO: Mutação direta do estado na memória heap!
function Perfil() {
const [usuario, setUsuario] = useState({ nome: 'Flavio', cargo: 'Dev' });
function alterarNome() {
usuario.nome = 'Ana Paula'; // Modificou a propriedade no mesmo objeto!
setUsuario(usuario); // Object.is(usuario, usuario) é TRUE -> React IGNORA o re-render!
}
return <h1>{usuario.nome}</h1>;
}
Mesmo que o valor interno tenha mudado na memória, a tela não será atualizada porque a referência de memória entregue a setUsuario permaneceu idêntica. Para que o React reconheça a alteração, você deve sempre criar um novo objeto com um novo endereço de memória.
3. Atualizando Objetos com o Operador Spread (…)
O padrão idiomático do ecossistema React para atualizar objetos imutavelmente é combinar a Atualização Funcional com o Operador Spread (...) do ES6:
// ✅ FORMA CORRETA: Cria um novo objeto copiando as propriedades anteriores
function alterarNomeCorreto() {
setUsuario(prev => ({
...prev, // Copia todas as propriedades existentes (cargo: ___WZW_STR_0___)
nome: 'Ana Paula' // Sobrescreve apenas a propriedade desejada
}));
}
⚠️ Atenção com Objetos Aninhados (Nested Objects)
O operador spread realiza apenas uma cópia superficial (shallow copy). Se o seu objeto possuir propriedades aninhadas, como endereco: { cidade: 'São Paulo' }, fazer apenas { ...prev, cidade: 'Rio' } não funcionará.
Você precisa espalhar cada nível da hierarquia:
setUsuario(prev => ({
...prev,
endereco: {
...prev.endereco,
cidade: 'Rio de Janeiro'
}
}));
4. Guia Definitivo de Manipulação Imutável de Arrays
Arrays no JavaScript possuem métodos que mutam o array original no lugar (mutating methods) e métodos que retornam um novo array sem alterar o original (pure methods). No React, você deve utilizar exclusivamente os métodos puros:
| Operação | ❌ Evite (Muta o Array) | ✅ Use no React (Gera Novo Array) |
|---|---|---|
| Adicionar item | arr.push(item)arr.unshift(item) |
setItens(prev => [...prev, novoItem]) (no fim)setItens(prev => [novoItem, ...prev]) (no início) |
| Remover item | arr.splice(index, 1)arr.pop() |
setItens(prev => prev.filter(item => item.id !== idRemover)) |
| Atualizar item | arr[index].feito = true |
setItens(prev => prev.map(item => item.id === id ? { ...item, feito: true } : item)) |
| Ordenar itens | arr.sort()arr.reverse() |
setItens(prev => [...prev].sort((a, b) => a.valor - b.valor)) |
5. Exemplo Completo de Lista de Tarefas Imutável
Veja como essas três operações fundamentais (adicionar, alternar status e remover) convivem harmoniosamente em um componente do mundo real:
function GerenciadorTarefas() {
const [tarefas, setTarefas] = useState([
{ id: 1, texto: 'Estudar React', concluido: false }
]);
// 1. Inserir (Spread)
const adicionarTarefa = (texto) => {
const nova = { id: Date.now(), texto, concluido: false };
setTarefas(prev => [...prev, nova]);
};
// 2. Alternar Status (Map + Spread)
const alternarConcluido = (id) => {
setTarefas(prev => prev.map(tarefa =>
tarefa.id === id ? { ...tarefa, concluido: !tarefa.concluido } : tarefa
));
};
// 3. Deletar (Filter)
const removerTarefa = (id) => {
setTarefas(prev => prev.filter(tarefa => tarefa.id !== id));
};
return (/* JSX da lista */);
}
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