Benchmark: Lodash isEqual compare with custom deepEqual in compare objects

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

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 months 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
_.isEqual Level 1	1903567.0 Ops/sec
deepEquals Level 1	5662413.5 Ops/sec
_.isEqual Level 2	1222174.5 Ops/sec
deepEquals Level 2	4843581.0 Ops/sec
_.isEqual Level 3	925508.5 Ops/sec
deepEquals Level 3	4239851.5 Ops/sec

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

Benchmark Overview

The provided JSON represents a JavaScript benchmark test, specifically testing the performance of the _.isEqual function from Lodash and a custom implementation called deepEquals. The benchmark measures how fast each function can compare two objects.

Test Cases

There are four test cases:

_.isEqual Level 1: Compares window.foo1 with window.bar1.
_ deepEquals Level 1: Uses the custom implementation deepEquals to compare window.foo1 with window.bar1.
_.isEqual Level 2: Compares window.foo2 with window.bar2.
_deepEquals Level 2: Uses the custom implementation deepEquals to compare window.foo2 with window.bar2.

Custom Implementation: deepEquals

The custom implementation deepEquals is used in test cases 1 and 2. This function recursively compares two objects using the following approach:

Primitive values: If both objects have a primitive value (e.g., number, string), it checks if they are equal.
Object properties: If one object has properties that the other doesn't, or if their property names don't match, it returns false.
Nested objects: It recursively calls deepEquals on nested objects.

Lodash Implementation: _.isEqual

The Lodash implementation _.isEqual is used in test cases 3 and 4. This function uses a similar approach to deepEquals, but with some additional optimizations:

Primitive values: Same as above.
Object properties: Same as above, with an added check for object prototypes.
Nested objects: It also recursively calls itself on nested objects.

Benchmark Results

The latest benchmark results show that the custom implementation deepEquals is faster than Lodash's _isEqual function for all test cases. The exact execution rates vary across different browsers and devices, but overall, deepEquals outperforms _isEqual.

Here are some possible reasons why deepEquals might be faster:

Custom optimization: The custom implementation can be optimized to work around specific browser quirks or limitations that the Lodash implementation doesn't address.
Reduced overhead: Without the additional overhead of Lodash's internal framework and testing infrastructure, deepEquals might execute slightly faster.
Lower memory usage: Depending on the specific use case, deepEquals might require less memory than _isEqual, especially when dealing with large objects.

However, it's essential to note that these results are highly dependent on the specific test cases, browser versions, and device configurations used. In general, using established libraries like Lodash can be beneficial due to their rigorous testing, performance optimization, and maintainability.

To summarize:

_.isEqual from Lodash is a well-tested and optimized implementation for comparing objects.
The custom implementation deepEquals provides an alternative approach with potential advantages in specific scenarios.
Benchmark results indicate that deepEquals outperforms _isEqual_ but should be evaluated based on the specific requirements of your project.

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript benchmark test, specifically testing the performance of the `_.isEqual` function from Lodash and a custom implementation called `deepEquals`. The benchmark measures how fast each function can compare two objects.

**Test Cases**

There are four test cases:

1.  **_.isEqual Level 1**: Compares `window.foo1` with `window.bar1`.
2.  **_ deepEquals Level 1**: Uses the custom implementation `deepEquals` to compare `window.foo1` with `window.bar1`.
3.  **_.isEqual Level 2**: Compares `window.foo2` with `window.bar2`.
4.  **_deepEquals Level 2**: Uses the custom implementation `deepEquals` to compare `window.foo2` with `window.bar2`.

**Custom Implementation: deepEquals**

The custom implementation `deepEquals` is used in test cases 1 and 2. This function recursively compares two objects using the following approach:

*   **Primitive values**: If both objects have a primitive value (e.g., number, string), it checks if they are equal.
*   **Object properties**: If one object has properties that the other doesn't, or if their property names don't match, it returns false.
*   **Nested objects**: It recursively calls `deepEquals` on nested objects.

**Lodash Implementation: _.isEqual**

The Lodash implementation `_.isEqual` is used in test cases 3 and 4. This function uses a similar approach to `deepEquals`, but with some additional optimizations:

*   **Primitive values**: Same as above.
*   **Object properties**: Same as above, with an added check for object prototypes.
*   **Nested objects**: It also recursively calls itself on nested objects.

**Benchmark Results**

The latest benchmark results show that the custom implementation `deepEquals` is faster than Lodash's `_isEqual` function for all test cases. The exact execution rates vary across different browsers and devices, but overall, `deepEquals` outperforms `_isEqual`.

Here are some possible reasons why `deepEquals` might be faster:

*   **Custom optimization**: The custom implementation can be optimized to work around specific browser quirks or limitations that the Lodash implementation doesn't address.
*   **Reduced overhead**: Without the additional overhead of Lodash's internal framework and testing infrastructure, `deepEquals` might execute slightly faster.
*   **Lower memory usage**: Depending on the specific use case, `deepEquals` might require less memory than `_isEqual`, especially when dealing with large objects.

To summarize:

*   `_.isEqual` from Lodash is a well-tested and optimized implementation for comparing objects.
*   The custom implementation `deepEquals` provides an alternative approach with potential advantages in specific scenarios.
*   Benchmark results indicate that `deepEquals` outperforms `_isEqual_` but should be evaluated based on the specific requirements of your project.

Related benchmarks:

Lodash isEqual compare with custom deepEqual in compare objects (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

Created: 4 years ago by: Registered User

Jump to the latest result

_.isEqual Level 1

deepEquals Level 1

_.isEqual Level 2

deepEquals Level 2

_.isEqual Level 3

deepEquals Level 3

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