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

AخA
 
<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] } } };

​x
 
// 1 level deepwindow.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 deepwindow.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 deepwindow.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)
_.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);

 
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)
_.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);

 
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)
_.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);

 
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: 2 years ago)

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

Browser/OS: Chrome 105 on Windows

View result in a separate tab

Test name	Executions per second
_.isEqual 1	596294.6 Ops/sec
Custom Recursive Function 1	324546.4 Ops/sec
_.isEqual 2	390322.2 Ops/sec
Custom Recursive Function 2	158911.4 Ops/sec
_.isEqual 3	244106.0 Ops/sec
Custom Recursive Function 3	62041.2 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

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:

Lodash isEqual: A widely-used utility function from the Lodash library that checks for deep equality between two objects.
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:

.isEqual 1: Tests Lodash isEqual on two objects with one level of nested structure (foo1 and bar1).
.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.
Custom Recursive Function 1: Tests the custom recursive function on an object with one level of nested structure (foo3 and bar3).
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.
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.

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: