Como especialista em desenvolvimento web com mais de 10 anos de experiência, posso afirmar com segurança que comparar objetos JavaScript é um dos desafios mais comuns — e muitas vezes traiçoeiros — que enfrentamos ao programar. Apesar de parecer algo simples, envolve nuances que podem causar muitos bugs se não forem bem compreendidas.
Como afiliado, podemos receber comissão por compras qualificadas, sem custo extra para você.
Acima de tudo, este guia é ideal para quem quer dominar de uma vez por todas como comparar objetos JavaScript, explorando desde as técnicas mais simples até as abordagens mais robustas.
O que significa comparar objetos JavaScript?
Antes de mais nada, precisamos entender que em JavaScript, objetos são estruturas de referência. Ou seja, quando você compara dois objetos diretamente, o que está sendo comparado são suas referências na memória, e não os valores que contêm.
Por que simplesmente usar “===” não funciona?
Em primeiro lugar, veja o seguinte exemplo:
javascriptCopiarEditarconst obj1 = { nome: "João" };
const obj2 = { nome: "João" };
console.log(obj1 === obj2); // false
Apesar de obj1 e obj2 terem exatamente o mesmo conteúdo, o resultado é false. Afinal, são duas referências distintas.
Como funciona a comparação por referência?
Primeiramente, toda vez que criamos um objeto em JavaScript, o motor da linguagem aloca um espaço único na memória. Mesmo que o conteúdo seja idêntico, as referências são diferentes.
Além disso, operadores como == e === só verificam se as referências apontam para o mesmo local.
Técnicas básicas para comparar objetos JavaScript
Agora que entendemos o problema, vamos às soluções.
Usando JSON.stringify
Antes de mais nada, essa é a forma mais direta:
javascriptCopiarEditarconst obj1 = { nome: "João" };
const obj2 = { nome: "João" };
console.log(JSON.stringify(obj1) === JSON.stringify(obj2)); // true
Apesar disso, essa abordagem possui limitações importantes.
Limitações do JSON.stringify
- Não lida bem com funções.
- Não preserva tipos como
undefinedouSymbol. - Ordem das propriedades influencia o resultado.
Ou seja, é uma solução rápida, mas não confiável para casos mais complexos.
Comparar objetos JavaScript profundamente: Deep Equality
Acima de tudo, quando falamos em comparar objetos JavaScript profundamente, nos referimos à verificação recursiva de cada chave e valor.
Implementando uma função de comparação profunda
Antes de mais nada, veja este exemplo de função:
javascriptCopiarEditarfunction deepEqual(obj1, obj2) {
if (obj1 === obj2) return true;
if (typeof obj1 != "object" || obj1 == null ||
typeof obj2 != "object" || obj2 == null) {
return false;
}
const keys1 = Object.keys(obj1);
const keys2 = Object.keys(obj2);
if (keys1.length !== keys2.length) return false;
for (let key of keys1) {
if (!keys2.includes(key) || !deepEqual(obj1[key], obj2[key])) {
return false;
}
}
return true;
}
Bem como o JSON.stringify, esta função verifica todas as propriedades, mas de maneira mais robusta.
Principais desafios ao comparar objetos JavaScript
Ordem das propriedades
Apesar disso, segundo o padrão ECMAScript, a ordem de propriedades pode ser imprevisível em algumas situações. Portanto, contar com a ordenação pode gerar falhas.
Valores aninhados e funções
Além disso, funções dentro de objetos não podem ser comparadas diretamente. Do mesmo modo, tipos complexos como Map, Set ou Date precisam de tratamentos especiais.
Bibliotecas que facilitam comparar objetos JavaScript
Principalmente quando buscamos robustez, vale usar bibliotecas consolidadas. Veja algumas:
Lodash – isEqual
Sobretudo, a função _.isEqual do Lodash é uma das mais confiáveis:
javascriptCopiarEditarconst _ = require('lodash');
console.log(_.isEqual({ a: 1 }, { a: 1 })); // true
Além disso, lida bem com arrays, objetos aninhados e outros tipos complexos.
Fast-deep-equal
Do mesmo modo, fast-deep-equal é uma biblioteca leve e muito eficiente:
javascriptCopiarEditarconst equal = require('fast-deep-equal');
console.log(equal({ a: 1 }, { a: 1 })); // true
Quando usar comparação rasa ou profunda?
Primeiramente, tudo depende do contexto:
- Comparação rasa: ideal para objetos simples e de poucas propriedades.
- Comparação profunda: essencial para estruturas complexas e aninhadas.
Ou seja, entenda bem o seu caso antes de escolher.
Comparar objetos JavaScript em arrays
Em outras palavras, comparar objetos dentro de arrays adiciona uma camada extra de complexidade.
Exemplo clássico
javascriptCopiarEditarconst arr1 = [{ id: 1 }, { id: 2 }];
const arr2 = [{ id: 1 }, { id: 2 }];
console.log(JSON.stringify(arr1) === JSON.stringify(arr2)); // true
Apesar disso, lembre-se: se a ordem mudar, o resultado será false.
Como evitar problemas comuns na comparação
Antes de mais nada, seguem algumas boas práticas:
- Normalize os objetos antes da comparação.
- Evite confiar em
JSON.stringifyem casos críticos. - Use bibliotecas quando necessário.
- Escreva testes unitários que cubram comparações complexas.
Casos em que NÃO devemos comparar objetos diretamente
Principalmente quando lidamos com estados em frameworks como React, a comparação direta pode levar a renderizações desnecessárias.
Em outras palavras, opte sempre por comparações otimizadas e, se possível, use técnicas de memoização.
Aplicando comparação de objetos JavaScript em projetos reais
Sobretudo, entender como comparar objetos JavaScript é vital em casos como:
- Sincronização de dados.
- Controle de estado.
- Testes automatizados.
Por exemplo, ao verificar se houve alteração no estado global de uma aplicação.
Testando a comparação de objetos JavaScript na prática
A princípio, sugiro que você crie pequenos scripts e simule diferentes cenários. Bem como:
- Comparar objetos idênticos.
- Comparar objetos aninhados.
- Comparar arrays de objetos.
- Lidar com funções internas.
Nesse sentido, só assim você terá domínio completo sobre o tema.
Dicas avançadas sobre comparar objetos JavaScript
Cuidado com o NaN
Por exemplo:
javascriptCopiarEditarconsole.log(NaN === NaN); // false
Ou seja, se NaN estiver dentro do objeto, cuidado redobrado!
Manipule Symbol e undefined
Além disso, propriedades com Symbol ou undefined exigem verificações específicas, pois JSON.stringify simplesmente ignora esses valores.
Boas práticas de performance
Apesar disso, nem sempre a comparação profunda é a melhor escolha. Principalmente em aplicações de alta performance, prefira técnicas como:
- Hashing.
- Checksums.
- Identificadores únicos.
Assim, evita-se o custo computacional de verificar toda a estrutura.
O que vem pela frente no JavaScript sobre comparação de objetos?
A princípio, ainda não há previsão de que o JavaScript introduza nativamente uma função deepEqual. Contudo, propostas e discussões sempre surgem na comunidade.
Portanto, por enquanto, seguimos confiando em boas implementações próprias ou bibliotecas consagradas.
Minhas Impressões Pessoais
Pessoalmente, acho essencial dominar como comparar objetos JavaScript, pois é uma habilidade que impacta diretamente na qualidade e robustez do código. Além disso, ter clareza sobre quando usar comparação rasa ou profunda evita muitos erros e otimiza o desempenho de aplicações reais.
Notebook Acer Aspire 5 A15-51M-54E6 Intel Core I5 13° Geração H 8GB RAM 512GB SSD Tela 15.6 TN FHD 60Hz (UHD para processadores Intel) Windows 11 Home
Notebook Acer Aspire 3 A315-510P-35D2 Intel Core i3, 8GB RAM, 512GB SSD, 15.6” LED FULL HD, Windows 11
Notebook Acer Aspire 5 A515-45-R0XR AMD Ryzen 7 5700U Tela 15.6" RAM 8 GB 256 GB SSD Linux Prata
Perguntas Frequentes (FAQ)
Você pode usar a função JSON.stringify() para converter os objetos em strings e, em seguida, comparar as strings resultantes. Isso funciona bem para objetos simples.
Sim! Você pode usar bibliotecas como Lodash com a função _.isEqual() ou implementar sua própria função de comparação recursiva.
A comparação com JSON.stringify() ainda funcionará, já que a ordem das propriedades não importa na string resultante.
