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>

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

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month 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 2 months ago):

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.

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.

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