Benchmark: compare arrays - MeasureThat.net

HTML Preparation code:

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

Script Preparation code:

window.foo = ['cat', 'dog', 'bird'];
window.bar = ['cat', 'dog', 'bird'];

window.equals = (a, b) =>
  a.length === b.length &&
  a.every((v, i) => v === b[i]);

window.equalsIgnoreOrder = (a, b) => {
  if (a.length !== b.length) return false;
  const uniqueValues = new Set([...a, ...b]);
  for (const v of uniqueValues) {
    const aCount = a.filter(e => e === v).length;
    const bCount = b.filter(e => e === v).length;
    if (aCount !== bCount) return false;
  }
  return true;
}

Tests:

_.isEqual
_.isEqual(window.foo, window.bar)
JSON.stringify
JSON.stringify(window.foo) === JSON.stringify(window.bar);
equals
window.equals(window.foo, window.bar)
equalsIgnoreOrder
window.equalsIgnoreOrder(window.foo, window.bar)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.isEqual
JSON.stringify
equals
equalsIgnoreOrder

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark JSON and explore what's being tested.

**Benchmark Definition**
The benchmark compares three different methods to compare two arrays: `lodash`'s `_isEqual` function, `JSON.stringify` with equality check using `===`, and a custom `equals` function implemented by the test user. The third method is an implementation of the "ignore order" approach for comparing arrays, which ignores the original order of elements when checking for equality.

**Options Compared**

1. **_.isEqual (Lodash)**: This function checks if two objects are equal, ignoring the order of properties and only considering enumerable own properties.
2. **JSON.stringify + ===**: This method converts both arrays to strings using `JSON.stringify` and then compares these strings using the `===` operator. Since this approach converts the arrays to strings, it doesn't take into account any potential differences in element order or data type.
3. **equals (Custom)**: This function checks if two arrays have the same length and, for each element, checks if both elements are equal. If the lengths differ, it returns `false`. If an element is missing from one array compared to the other, it also returns `false`.

**Pros and Cons**

* **_.isEqual (Lodash)**:
	+ Pros: Efficiently handles complex object structures and ignores property order.
	+ Cons: May have a performance overhead due to its complexity, especially for large objects or arrays.
* **JSON.stringify + ===**:
	+ Pros: Simple to implement and has a low overhead. It's also easy to understand and debug.
	+ Cons: Converts the arrays to strings, which can lead to performance issues with large datasets. It doesn't take into account element order differences.
* **equals (Custom)**:
	+ Pros: Ignores element order and data type when comparing arrays. This approach is straightforward and easy to implement.
	+ Cons: Can be slower than the other approaches, especially for large arrays, since it needs to check each element individually.

**Library: Lodash**
Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks like array manipulation, object creation, and more. The `_isEqual` function in this benchmark is part of Lodash's `MoreUtils` module, which provides functions for comparing objects and arrays.

**Special JS Feature/ Syntax: None**
There are no special JavaScript features or syntaxes being used in this benchmark that would require additional explanation.

**Other Alternatives**

For comparing arrays, you can use other approaches like:

1. **Array.prototype.every() + ===**: Similar to the `JSON.stringify + ===` approach but using the `every()` method instead.
2. **Set-based comparison**: You can convert both arrays to sets and then compare them for equality. This approach is efficient for large datasets since set operations have a low overhead.
3. **Array.prototype.sort() + ===**: Sort both arrays and then compare them for equality. This approach takes into account element order differences, but may not be suitable for datasets where the original order matters.

These alternatives can provide different trade-offs between performance, complexity, and ease of implementation compared to the approaches tested in this benchmark.

Latest run results:

Run details: (Test run date: 17 hours ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:132.0) Gecko/20100101 Firefox/132.0

Browser/OS: Firefox 132 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
_.isEqual	2009297.9 Ops/sec
JSON.stringify	1581071.8 Ops/sec
equals	2752146.2 Ops/sec
equalsIgnoreOrder	647444.6 Ops/sec

Related benchmarks:

compare arrays (version: 0)

lodash vs json stringify and other methods

Comparing performance of: _.isEqual vs JSON.stringify vs equals vs equalsIgnoreOrder

Created: 2 years ago by: Guest

Jump to the latest result

_.isEqual

JSON.stringify

equals

equalsIgnoreOrder

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