Benchmark: Lodash isEqual test vs Custom Recursive Function

Lodash isEqual test vs Custom Recursive Function (version: 1)

Custom function checks K:V's match and ignores order of K:V's. Taken from: https://nathanworden.medium.com/deep-equality-in-javascript-objects-c98ec918e888 -- thank you!

Comparing performance of: _.isEqual 1 vs Custom Recursive Function 1 vs _.isEqual 2 vs Custom Recursive Function 2 vs _.isEqual 3 vs Custom Recursive Function 3

Created: 3 years ago by: Registered User

Jump to the latest result

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.4/lodash.min.js"></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,2], b: 2 } } };
window.bar2 = { a: 1, b: 2, c: { a: 1, b: 3, c: { a: [1,2], b: 2 } } };

// 3 levels deep
window.foo3 = { a: 1, b: 2, c: { a: 1, b: 2, c: { a: [1,2], b: [1,2] } } };
window.bar3 = { a: 1, b: 2, c: { a: 1, b: 2, c: { a: [1,2], b: [1,2] } } };

Tests:

_.isEqual 1
_.isEqual(window.foo1, window.bar1)
Custom Recursive Function 1
const areObjectKeysValuesEqual = (obj1, obj2) => { if (Object.keys(obj1).length !== Object.keys(obj2).length) { return false; } for (key of Object.keys(obj1)) { if (typeof obj1[key] === "object") { if (!areObjectKeysValuesEqual(obj1[key], obj2[key])) { return false; } } if (obj1[key] !== obj2[key]) { return false; } } return true; }; const result = areObjectKeysValuesEqual(window.foo1, window.bar1);
_.isEqual 2
_.isEqual(window.foo2, window.bar2)
Custom Recursive Function 2
const areObjectKeysValuesEqual = (obj1, obj2) => { if (Object.keys(obj1).length !== Object.keys(obj2).length) { return false; } for (key of Object.keys(obj1)) { if (typeof obj1[key] === "object") { if (!areObjectKeysValuesEqual(obj1[key], obj2[key])) { return false; } } if (obj1[key] !== obj2[key]) { return false; } } return true; }; const result = areObjectKeysValuesEqual(window.foo2, window.bar2);
_.isEqual 3
_.isEqual(window.foo3, window.bar3)
Custom Recursive Function 3
const areObjectKeysValuesEqual = (obj1, obj2) => { if (Object.keys(obj1).length !== Object.keys(obj2).length) { return false; } for (key of Object.keys(obj1)) { if (typeof obj1[key] === "object") { if (!areObjectKeysValuesEqual(obj1[key], obj2[key])) { return false; } } if (obj1[key] !== obj2[key]) { return false; } } return true; }; const result = areObjectKeysValuesEqual(window.foo3, window.bar3);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.isEqual 1
Custom Recursive Function 1
_.isEqual 2
Custom Recursive Function 2
_.isEqual 3
Custom Recursive Function 3

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:150.0) Gecko/20100101 Firefox/150.0

Browser/OS: Firefox 150 on Linux

View result in a separate tab

Test name	Executions per second
_.isEqual 1	1690388.9 Ops/sec
Custom Recursive Function 1	3251228.0 Ops/sec
_.isEqual 2	1112778.1 Ops/sec
Custom Recursive Function 2	2510521.8 Ops/sec
_.isEqual 3	630826.2 Ops/sec
Custom Recursive Function 3	855333.6 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its results.

**Benchmark Description**

The benchmark compares the performance of two approaches to check if two objects are equal:

1. **Lodash `isEqual`**: A widely-used utility function from the Lodash library that checks for deep equality between two objects.
2. **Custom Recursive Function**: A custom implementation of a recursive function that checks for deep equality between two objects.

**Options Compared**

The benchmark compares the performance of each approach on three different test cases:

1. **`.isEqual` 1**: Tests `Lodash isEqual` on two objects with one level of nested structure (`foo1` and `bar1`).
2. **`.isEqual` 2**: Tests `Lodash isEqual` on two objects with two levels of nested structure (`foo2` and `bar2`), which is not present in the provided benchmark data.
3. **Custom Recursive Function 1**: Tests the custom recursive function on an object with one level of nested structure (`foo3` and `bar3`).
4. **Custom Recursive Function 2**: Tests the custom recursive function on an object with two levels of nested structure (`foo4` and `bar4`), which is not present in the provided benchmark data.
5. **Custom Recursive Function 3**: Tests the custom recursive function on an object with three levels of nested structure (`foo5` and `bar5`).

**Latest Benchmark Results**

The latest benchmark results show that:

* `.isEqual` 1 outperforms Custom Recursive Function 1, indicating that Lodash's implementation is faster.
* `.isEqual` 2 does not have a corresponding test case in the provided data.
* Custom Recursive Function 3 outperforms Custom Recursive Function 2, suggesting that the function becomes less efficient as the nested structure increases.

**Key Takeaways**

The benchmark highlights the performance differences between Lodash's `isEqual` and a custom recursive implementation of object equality checks. The results suggest that:

* For simple objects with one level of nested structure, Lodash's implementation is faster.
* As the nested structure increases, the custom recursive function may become less efficient.

These findings can be useful for developers who need to optimize performance-critical code involving object equality checks.

Related benchmarks: