Benchmark: Lodash isEqual compare with custom deepEqual in compare objects 1

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.4/lodash.min.js"></script>
<script>
  
  function deepEquals(x, y, exceptionName) {
    if (x === y) {
        return true; // if both x and y are null or undefined and exactly the same
    }
    else if (!(x instanceof Object) || !(y instanceof Object)) {
        return false; // if they are not strictly equal, they both need to be Objects
    }
    else if (x.constructor !== y.constructor) {
        // they must have the exact same prototype chain, the closest we can do is
        // test their constructor.
        return false;
    }
    else {
        for (const p in x) {
            if (!x.hasOwnProperty(p)) {
                continue; // other properties were tested using x.constructor === y.constructor
            }
            if (!y.hasOwnProperty(p)) {
                return false; // allows to compare x[ p ] and y[ p ] when set to undefined
            }
            if (x[p] === y[p] || (!!exceptionName && p === exceptionName)) {
                continue; // if they have the same strict value or identity then they are equal
            }
            if (typeof x[p] !== 'object') {
                return false; // Numbers, Strings, Functions, Booleans must be strictly equal
            }
            if (!deepEquals(x[p], y[p])) {
                return false;
            }
        }
        for (const p in y) {
            if (y.hasOwnProperty(p) && !x.hasOwnProperty(p)) {
                return false;
            }
        }
        return true;
    }
}
</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:

_.isEqual Level 1
_.isEqual(window.foo1, window.bar1)
deepEquals Level 1
deepEquals(window.foo1, window.bar1);
_.isEqual Level 2
_.isEqual(window.foo2, window.bar2)
deepEquals Level 2
deepEquals(window.foo2, window.bar2);
_.isEqual Level 3
_.isEqual(window.foo3, window.bar3)
deepEquals Level 3
deepEquals(window.foo3, window.bar3);
native equals
window.foo3 === window.bar3

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.isEqual Level 1
deepEquals Level 1
_.isEqual Level 2
deepEquals Level 2
_.isEqual Level 3
deepEquals Level 3
native equals

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 24 days ago):

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark test cases and explain what's being tested, compared, and their pros/cons.

**Benchmark Test Cases:**

The benchmark test cases are designed to compare the performance of three different implementations:

1. `_.isEqual` (Lodash library)
2. Custom `deepEquals` function
3. Native equality operator (`===`)

Each test case measures the execution time for each implementation, allowing users to compare their performance.

**Test Case Breakdown:**

There are six test cases in total, with three levels of depth:

1. Level 1:
	* `_.isEqual(window.foo1, window.bar1)` and `deepEquals(window.foo1, window.bar1)`
	These tests compare two objects with similar properties.
2. Level 2:
	* `_.isEqual(window.foo2, window.bar2)` and `deepEquals(window.foo2, window.bar2)`
	These tests compare two objects with more complex structures.
3. Level 3:
	* `_.isEqual(window.foo3, window.bar3)` and `deepEquals(window.foo3, window.bar3)`
	These tests compare two deeply nested objects.

**Comparison:**

The benchmark results show the execution time for each implementation:

1. Native equality operator (`===`):
	* Fastest execution times across all test cases
	* Consistently outperforms Lodash and custom implementations
2. `_.isEqual` (Lodash library):
	* Slightly slower than native equality operator
	* Still relatively fast, but may be impacted by Lodash's complexity
3. Custom `deepEquals` function:
	* Slower than both native equality operator and Lodash
	* May be optimized further with additional testing

**Pros/Cons:**

**Native Equality Operator (`===`):**

Pros:

* Fastest execution times across all test cases
* Simple and efficient implementation

Cons:

* May not provide additional benefits for deeply nested objects or complex data structures
* Can lead to unexpected behavior if not used carefully (e.g., comparing objects with different types)

**Lodash Library (`_.isEqual`):**

Pros:

* Provides a well-tested and widely-used implementation
* Supports more advanced features, such as deep comparisons

Cons:

* Slightly slower than native equality operator
* May be impacted by Lodash's complexity and overhead

**Custom `deepEquals` Function:**

Pros:

* Can be optimized further with additional testing and fine-tuning
* Provides more control over the comparison process

Cons:

* Slower execution times compared to native equality operator and Lodash
* Requires more development effort and expertise to implement correctly

Latest run results:

Run details: (Test run date: 6 months ago)

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

Browser/OS: Chrome 124 on Windows

View result in a separate tab

Test name	Executions per second
_.isEqual Level 1	1275986.4 Ops/sec
deepEquals Level 1	3346476.5 Ops/sec
_.isEqual Level 2	829500.2 Ops/sec
deepEquals Level 2	2742466.5 Ops/sec
_.isEqual Level 3	621118.8 Ops/sec
deepEquals Level 3	2346973.2 Ops/sec
native equals	5631591.0 Ops/sec

Related benchmarks:

Lodash isEqual compare with custom deepEqual in compare objects 1 (version: 0)

Test on isEqual performance

Comparing performance of: _.isEqual Level 1 vs deepEquals Level 1 vs _.isEqual Level 2 vs deepEquals Level 2 vs _.isEqual Level 3 vs deepEquals Level 3 vs native equals

Created: 6 months ago by: Guest

Jump to the latest result

_.isEqual Level 1

deepEquals Level 1

_.isEqual Level 2

deepEquals Level 2

_.isEqual Level 3

deepEquals Level 3

native equals

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 24 days ago):