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>

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

​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, b: 2 } } };window.bar2 = { a: 1, b: 2, c: { a: 1, b: 3, c: { a: 1, b: 2 } } };​// 3 levels deepwindow.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)
_.isEqual(window.foo1, window.bar1)
deepEquals Level 1
deepEquals(window.foo1, window.bar1);
deepEquals(window.foo1, window.bar1);
_.isEqual Level 2
_.isEqual(window.foo2, window.bar2)
_.isEqual(window.foo2, window.bar2)
deepEquals Level 2
deepEquals(window.foo2, window.bar2);
deepEquals(window.foo2, window.bar2);
_.isEqual Level 3
_.isEqual(window.foo3, window.bar3)
_.isEqual(window.foo3, window.bar3)
deepEquals Level 3
deepEquals(window.foo3, window.bar3);
deepEquals(window.foo3, window.bar3);
native equals
window.foo3 === window.bar3
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 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

Latest run results:

Run details: (Test run date: 11 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

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

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:

_.isEqual (Lodash library)
Custom deepEquals function
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:

Level 1:
- _.isEqual(window.foo1, window.bar1) and deepEquals(window.foo1, window.bar1) These tests compare two objects with similar properties.
Level 2:
- _.isEqual(window.foo2, window.bar2) and deepEquals(window.foo2, window.bar2) These tests compare two objects with more complex structures.
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:

Native equality operator (===):
- Fastest execution times across all test cases
- Consistently outperforms Lodash and custom implementations
_.isEqual (Lodash library):
- Slightly slower than native equality operator
- Still relatively fast, but may be impacted by Lodash's complexity
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

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

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: 11 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 5 months ago):