Benchmark: Lodash isEqual test array of objects vs ===

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.4/lodash.min.js"></script>

Script Preparation code:

// 1 level deep
window.foo1 = [
  {id: "1035257027", person_id: "1043549930", group_id: "551225445", avatar_url: "http://people.pco.test/static/no_photo_thumbnail_gray.png", email_address: "pico@pco.bz"},
  {id: "1035257027", person_id: "1043549930", group_id: "551225445", avatar_url: "http://people.pco.test/static/no_photo_thumbnail_gray.png", email_address: "pico@pco.bz"},
];
window.bar1 = [
  {id: "1035257027", person_id: "1043549930", group_id: "551225445", avatar_url: "http://people.pco.test/static/no_photo_thumbnail_gray.png", email_address: "pico@pco.bz"},
  {id: "1035257025", person_id: "1043549930", group_id: "551225445", avatar_url: "http://people.pco.test/static/no_photo_thumbnail_gray.png", email_address: "pico@pco.bz"},
];

Tests:

_.isEqual different objects
_.isEqual(window.foo1, window.bar1)
=== different objects
window.foo1 === window.bar1;
=== same object
window.foo1 === window.foo1;
_.isEqual same object
_.isEqual(window.foo1, window.foo1)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.isEqual different objects
=== different objects
=== same object
_.isEqual same object

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36

Browser/OS: Chrome 113 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
_.isEqual different objects	1051150.2 Ops/sec
=== different objects	6566962.5 Ops/sec
=== same object	6939338.5 Ops/sec
_.isEqual same object	4805015.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the Benchmark Definition and explain what is tested on the provided JSON.

The benchmark compares three ways to compare arrays of objects for equality:

1. Using Lodash's `isEqual` function (`_.isEqual(window.foo1, window.bar1)`).
2. Using the strict equality operator (`===`) with two different arrays (`window.foo1 === window.bar1;` and `window.foo1 === window.foo1;`).
3. Using a simple comparison of object references (which is not recommended) (`window.foo1 === window.bar1;`).

Let's break down each option:

**Option 1: Lodash's `isEqual` function**

Lodash's `isEqual` function is a utility function that checks if two values are equal, taking into account various types such as arrays, objects, numbers, and more. In this benchmark, it's used to compare the `foo1` and `bar1` arrays.

Pros:

* Can handle complex data structures, such as nested arrays or objects.
* Handles cases where the arrays have different lengths or elements in different positions.

Cons:

* May be slower than a simple comparison due to its complexity.
* Requires an additional library (Lodash) to be included in the test environment.

**Option 2: Strict equality operator (`===`)**

The strict equality operator compares the values of two expressions using their string representations. In this benchmark, it's used to compare the `foo1` and `bar1` arrays directly.

Pros:

* Fast comparison, as it only requires a simple value-by-value comparison.
* Does not require any additional libraries or setup.

Cons:

* May return incorrect results if the arrays are not identical, even if they contain the same values. For example, if `foo1` and `bar1` have different lengths, `===` will return false.
* May be vulnerable to common JavaScript gotchas like "same object reference" issues (more on this later).

**Option 3: Simple comparison of object references (`window.foo1 === window.bar1;`)**

This option is not recommended as it's prone to errors. In JavaScript, objects are passed by reference, so comparing two variables using `===` only checks if they point to the same memory location. If this condition is met, it means both variables refer to the same object in memory.

Pros: None (this option has significant limitations).

Cons:

* Returns incorrect results if the arrays have different elements or are not identical.
* Can lead to confusing errors when debugging, as the comparison only checks for identity rather than equality.

Now, let's talk about special JavaScript features used in this benchmark. There is no explicit mention of any specific features like `let` or `const`, but the use of `window` variables suggests that the test environment uses a global scope with variable declarations.

Other alternatives to compare arrays:

* JSON.stringify(): This can be used to create a string representation of an object, which can then be compared using `===`.
* Object.is(): This is a more modern equality check function introduced in ECMAScript 2015 (ES6). It's similar to `===` but uses a more nuanced comparison that handles edge cases better.
* Arrays.prototype.every() and Arrays.prototype.some(): These methods can be used to compare arrays element-wise, allowing for more precise control over the comparison process.

Keep in mind that different browsers or JavaScript engines might have slightly different performance characteristics for these alternatives.

Related benchmarks:

Lodash isEqual test array of objects vs === (version: 0)

Test on isEqual performance

Comparing performance of: _.isEqual different objects vs === different objects vs === same object vs _.isEqual same object

Created: one year ago by: Guest

Jump to the latest result

_.isEqual different objects

=== different objects

=== same object

_.isEqual same object

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):