Benchmark: isDeepEqual vs isEqual

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.4/lodash.min.js"></script>
<script>
  
  function deepEquals(object1, object2, compareKeys) {
  let objKeys1 = Object.keys(object1);
  let objKeys2 = Object.keys(object2);

  if (compareKeys) {
    objKeys1 = objKeys1.filter(key => compareKeys.includes(key));
    objKeys2 = objKeys2.filter(key => compareKeys.includes(key));
  }

  if (objKeys1.length !== objKeys2.length) {
    return false;
  }

  for (const key of objKeys1) {
    const value1 = object1[key];
    const value2 = object2[key];

    const isObjects = isObjectOrArray(value1) && isObjectOrArray(value2);

    if ((isObjects && !deepEquals(value1, value2)) || (!isObjects && value1 !== value2)) {
      return false;
    }
  }
  return true;
}
  
  function isObjectOrArray(input) {
  	return input != null && typeof input === 'object';
  } 
</script>

Script Preparation code:

// 1 level deep
window.foo1 = { a: 1, b: 2, c: { a: 1, b: 2, c: { a: 1, b: 2 } } };
window.bar1 = { a: 1, b: 3, c: { a: 1, b: 2, c: { a: 1, b: 2 } } };

// 2 levels deep
window.foo2 = { a: 1, b: 2, c: { a: 1, b: 2, c: { a: 1, b: 2 } } };
window.bar2 = { a: 1, b: 2, c: { a: 1, b: 3, c: { a: 1, b: 2 } } };

// 3 levels deep
window.foo3 = { a: 1, b: 2, c: { a: 1, b: 2, c: { a: 1, b: 2 } } };
window.bar3 = { a: 1, b: 2, c: { a: 1, b: 2, c: { a: 1, b: 4 } } };

Tests:

isEqualLevel 1
_.isEqual(window.foo1, window.bar1)
deepEquals 1
deepEquals(window.foo1, window.bar1);
isEqualLevel 2
_.isEqual(window.foo2, window.bar2)
deepEquals 2
deepEquals(window.foo2, window.bar2);
isEquallevel 3
_.isEqual(window.foo3, window.bar3);
deepEquals 3
deepEquals(window.foo3, window.bar3);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
isEqualLevel 1
deepEquals 1
isEqualLevel 2
deepEquals 2
isEquallevel 3
deepEquals 3

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
isEqualLevel 1	2061633.2 Ops/sec
deepEquals 1	5075647.5 Ops/sec
isEqualLevel 2	1182961.8 Ops/sec
deepEquals 2	4081410.5 Ops/sec
isEquallevel 3	920559.9 Ops/sec
deepEquals 3	3407464.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark you're looking at compares two different methods of checking deep equality of JavaScript objects: using the Lodash library's `_.isEqual` function, and a custom function named `deepEquals`. This benchmarking is conducted on three pairs of objects that vary in their structure by levels of depth—1, 2, and 3. Each test case utilizes two objects, with one serving as a baseline for equality (e.g., `foo1`, `foo2`, `foo3`) and the other slightly modified to induce inequality (e.g., `bar1`, `bar2`, `bar3`).

### Benchmark Comparison

1. **`_.isEqual` from Lodash**:
   - **Description**: `_.isEqual` is a utility function from the Lodash library that performs a deep comparison between two values to determine if they are equivalent. Lodash is a widely used JavaScript library that provides various utility functions for common programming tasks, which include data manipulations, collections, and more.
   - **Pros**:
     - Highly optimized for performance: Lodash is well-tested and optimized for various scenarios, making it a reliable choice for developers.
     - Widely adopted and documented: As a popular library, it has good community support and ample documentation.
   - **Cons**:
     - Adds external dependency: Using Lodash means adding additional bytes to your project, which can be a concern for performance-sensitive applications.
     - May not be customizable: As a library function, its internal workings are fixed, which limits tweaking for specific use cases.

2. **Custom `deepEquals` Function**:
   - **Description**: The `deepEquals` function defined in the benchmark performs a recursive comparison of object properties to determine equality. It checks if both objects have the same keys and recursively compares their values.
     - It includes a helper function `isObjectOrArray` that checks if a value is either an object or an array.
   - **Pros**:
     - Lightweight: Being a custom-built function, it doesn't introduce external dependencies.
     - Flexibility: It is customizable, allowing developers to modify its logic as required for specific situations.
   - **Cons**:
     - Potentially less optimized: Custom implementations may not be as efficient as well-tuned library functions, especially for larger and more complex objects.
     - More maintenance: As a custom code, it may require additional testing and bug fixing over time.

### Test Cases
The benchmark consists of six tests, with each comparing the performance of `_.isEqual` and `deepEquals` at varying depths:

1. **isEqualLevel 1**: Comparison of `foo1` and `bar1` at 1 level deep.
2. **deepEquals 1**: Similar comparison using the custom function.
3. **isEqualLevel 2**: Comparison of `foo2` and `bar2` at 2 levels deep.
4. **deepEquals 2**: Comparison using the custom function at 2 levels.
5. **isEqualLevel 3**: Comparison of `foo3` and `bar3` at 3 levels deep.
6. **deepEquals 3**: Comparison using the custom function at 3 levels deep.

### Considerations and Alternatives
When deciding between these methods, developers need to consider the specific requirements of their applications, such as:

- **Performance vs. Flexibility**: If performance is critical and the project can afford an additional library, using Lodash might be the preferred option. Conversely, if a lightweight solution is needed with specific logical customization, then a custom solution could be the better choice.
- **Complexity of Objects**: If comparing very complex nested structures, one may also consider other libraries or methods that specialize in deep equality checks. For example, libraries like `fast-deep-equal` focus on speed and performance with deep comparisons at the cost of fewer features compared to Lodash.

### Conclusion
The benchmark results show that `deepEquals` outperformed `_.isEqual` across all test cases. This highlights the possibility that a well-optimized custom implementation can outperform a general-purpose library function, depending on the specific workload. Each approach has its strengths and weaknesses, and the appropriate choice ultimately depends on the specific context of use, performance needs, and future maintainability.

Related benchmarks:

isDeepEqual vs isEqual (version: 1)

Comparing performance of: isEqualLevel 1 vs deepEquals 1 vs isEqualLevel 2 vs deepEquals 2 vs isEquallevel 3 vs deepEquals 3

Created: one month ago by: Guest

Jump to the latest result

isEqualLevel 1

deepEquals 1

isEqualLevel 2

deepEquals 2

isEquallevel 3

deepEquals 3

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):