Estados Complexos no React: Objetos e Arrays
⚡ Curso de React.js • Web-ZoneWare

Gerenciando Estados Complexos no React: Objetos, Arrays & Imutabilidade

Lição 14 de 50

Gerenciando Estados Complexos no React: Objetos, Arrays & Imutabilidade

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):

JavaScript 7 linhas
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:

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

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

CODE 25 linhas
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 */);
}
🛠️ 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