Skip to content
Subscribe to RSS Find me on GitHub Follow me on Twitter

Comparing Two Objects in JavaScript: Finding Differences


When working with JavaScript, it is often necessary to compare two objects to determine if they are equal or to identify any differences between them. Comparing objects can be challenging due to the way JavaScript handles object references. However, it is a crucial task in many scenarios, such as validating form input, determining changes in state, or testing the equality of complex data structures.

This article aims to provide an overview of the different techniques available to compare objects in JavaScript, highlighting the importance of accurately comparing objects and the various approaches that can be used to accomplish this task. We will explore both shallow and deep comparison methods and discuss their limitations and use cases.

By the end of this article, you will have a solid understanding of how to compare objects effectively in JavaScript, enabling you to handle complex data structures and make informed decisions based on the comparison results.

Comparing Objects: An Overview

When comparing objects in JavaScript, there are two main approaches: shallow comparison and deep comparison.

Shallow comparison involves comparing the references of the objects rather than their actual contents. This can be done using the triple equals (===) operator, which checks if two objects refer to the same location in memory. Shallow comparison is simple and efficient but it only checks if the objects are the same, not if their contents are equal. It does not consider the properties and values inside the objects.

On the other hand, deep comparison involves comparing the actual properties and values of the objects. This requires traversing through the objects and comparing each property and value recursively. Deep comparison provides a more thorough analysis of the objects' differences. It can be implemented by writing a custom function that iterates over the properties and compares their values. Deep comparison is useful when you want to find the exact differences between two objects.

Comparing objects in JavaScript can be challenging due to various factors. One challenge is that objects can contain nested objects or arrays, which adds complexity to the comparison process. Another challenge is handling circular references, where an object references itself or references another object that references it. Circular references can lead to infinite loops if not properly handled. Additionally, objects can inherit properties and methods from their prototypes, which may need to be considered when comparing objects.

In the subsequent sections, we will explore both shallow and deep comparison in more detail and discuss how to overcome these challenges.

Shallow Comparison

In JavaScript, shallow comparison is a technique used to compare two objects based on their reference. It checks whether the two objects point to the same location in memory. Shallow comparison is often performed using the triple equals (===) operator.

When using the triple equals operator to compare two objects, it checks if they refer to the same object in memory. If they do, it returns true; otherwise, it returns false. Shallow comparison is useful when you only need to determine if two objects are identical in terms of their reference.

const obj1 = { name: 'John', age: 30 };
const obj2 = { name: 'John', age: 30 };
const obj3 = obj1;

console.log(obj1 === obj2); // false
console.log(obj1 === obj3); // true

However, it's important to note that shallow comparison has limitations. It does not compare the properties and values inside the objects. If the objects have the same properties and values, but are located in different memory locations, the shallow comparison will return false.

Shallow comparison also does not account for nested objects or arrays within the objects. If the objects contain nested structures, the comparison will only check the references to those structures and not their contents.

const obj4 = { name: 'John', address: { city: 'New York', country: 'USA' } };
const obj5 = { name: 'John', address: { city: 'New York', country: 'USA' } };

console.log(obj4 === obj5); // false

In this example, even though obj4 and obj5 have the same properties and values, the shallow comparison returns false because the nested address objects have different references.

In conclusion, while shallow comparison is a quick way to check if two objects have the same reference in memory, it does not provide a comprehensive comparison of their properties and values. To perform a more detailed comparison, including nested structures, a deep comparison technique is required.

Deep Comparison

Deep comparison is a technique used to compare two objects in JavaScript by comparing not only their properties, but also the values of those properties. Unlike shallow comparison, which only checks if the two objects have the same reference, deep comparison examines the actual contents of the objects.

To implement a deep comparison, you can create a custom function that compares each property and value of the two objects recursively. This means that if a property of an object is another object, the function will go deeper into that nested object and compare its properties as well.

By comparing properties and values recursively, you can identify the differences between the two objects in a detailed manner. This allows you to retrieve information about which properties have different values and even provide a list of those differences.

Here is an example of a custom function for deep comparison:

function deepCompare(obj1, obj2) {
  // Check if the objects have the same number of properties
  if (Object.keys(obj1).length !== Object.keys(obj2).length) {
    return false;

  // Compare each property and value recursively
  for (let key in obj1) {
    if (typeof obj1[key] === "object" && typeof obj2[key] === "object") {
      if (!deepCompare(obj1[key], obj2[key])) {
        return false;
    } else if (obj1[key] !== obj2[key]) {
      return false;

  return true;

This function takes two objects, obj1 and obj2, as arguments. It first checks if the objects have the same number of properties. If not, it immediately returns false, indicating that the objects are not equal.

Next, it iterates over each property of obj1 and checks if the corresponding property in obj2 is also an object. If so, it recursively calls the deepCompare function to compare the nested objects. If the comparison returns false, it means there is a difference and the function returns false.

If the function finishes iterating over all properties without finding any differences, it returns true, indicating that the objects are deeply equal.

By implementing a deep comparison function like this, you can compare two objects in JavaScript and retrieve detailed information about the differences between them. This can be useful when working with complex data structures or when you need to ensure that two objects have the same values for all their properties.

Key Points to Consider

When comparing two objects in JavaScript, there are several key points to consider in order to ensure accurate and reliable comparisons:

  1. Avoiding potential pitfalls in object comparison: It is important to be aware of potential pitfalls when comparing objects in JavaScript. For example, using the triple equals (===) operator for a shallow comparison may not yield the expected results when dealing with complex objects. It is necessary to understand the limitations of different comparison techniques and choose the appropriate method accordingly.

  2. Accounting for nested objects and arrays: Objects in JavaScript can contain nested objects and arrays as properties. When performing a deep comparison, it is crucial to account for these nested structures to accurately compare the objects. This involves recursively traversing through the properties of the objects and checking their values for equality.

  3. Handling circular references and prototype properties: Circular references occur when an object references itself, either directly or indirectly. When comparing objects with circular references, it is important to handle them properly to avoid infinite loops. Additionally, prototype properties may also need to be considered during object comparison, depending on the specific use case.

By considering these key points, developers can ensure that their object comparisons in JavaScript are accurate, reliable, and handle various scenarios effectively.


In this article, we explored the topic of comparing two objects in JavaScript and finding their differences. We discussed the importance of correctly comparing objects and the challenges that come with it.

We learned about shallow comparison, which involves using the triple equals (===) operator to compare objects. While shallow comparison can be useful in certain scenarios, it has limitations and may not accurately capture all differences between objects.

To overcome these limitations, we explored deep comparison, which involves recursively comparing properties and values of objects. We implemented a custom function for deep comparison and discussed how it can provide detailed information about the differences between objects.

It is important to consider certain key points when comparing objects in JavaScript. We should account for nested objects and arrays, handle circular references, and be mindful of prototype properties.

By correctly comparing objects, we can ensure the accuracy and reliability of our code. For further learning and practice, it is recommended to explore more advanced techniques for comparing objects and to work on exercises that involve object comparison.

Comparing objects in JavaScript is a fundamental skill for any JavaScript developer, and mastering this skill will greatly enhance the ability to build complex applications.