Benchmark: compare arrays + toString

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)
toString
window.foo.toString() === window.bar.toString()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The benchmark definition is provided in JSON format, which outlines the test case and the methods being compared. In this case, we're comparing four methods:

1. `lodash.equals`: A function from the Lodash library that checks if two arrays are equal.
2. `JSON.stringify` with `===`: Compares two arrays by converting them to strings using `JSON.stringify`.
3. `window.equals`: A custom function that checks if two arrays are equal, ignoring order and duplicates.
4. `window.toString()`: Compares two arrays by converting them to strings using the `toString()` method.

**Methods Compared**

Each test case compares a pair of methods to determine which one is faster. The tests are:

1. `_.isEqual(window.foo, window.bar)`: Tests `lodash.equals` on the `foo` and `bar` arrays.
2. `JSON.stringify(window.foo) === JSON.stringify(window.bar)`: Tests `JSON.stringify` with `===` on the `foo` and `bar` arrays.
3. `window.equals(window.foo, window.bar)`: Tests the custom `equals` function on the `foo` and `bar` arrays.
4. `window.equalsIgnoreOrder(window.foo, window.bar)`: Tests the custom `equalsIgnoreOrder` function on the `foo` and `bar` arrays.
5. `window.foo.toString() === window.bar.toString()`: Tests the `toString()` method on the `foo` and `bar` arrays.

**Libraries**

The Lodash library is used in test case 1 (`_.isEqual(window.foo, window.bar)`). The Lodash library provides a set of functions for functional programming, including equality checks like `equals`.

**Special JS Features or Syntax**

There are no special JavaScript features or syntaxes mentioned in the benchmark definition. However, it's worth noting that the use of `===` operator for comparing arrays is not standard JavaScript behavior. It's more common to compare arrays using `Array.prototype.every()` or other methods.

**Pros and Cons of Different Approaches**

Here are some pros and cons of each approach:

1. `lodash.equals`: Fast, but depends on Lodash library.
	* Pros: Well-tested, efficient.
	* Cons: Adds dependency on Lodash library.
2. `JSON.stringify` with `===`: Slow, because string comparison is slower than array comparison.
	* Pros: No dependencies, easy to implement.
	* Cons: Slower, less accurate.
3. `window.equals`: Custom implementation that ignores order and duplicates.
	* Pros: Fast, flexible, can be optimized for specific use cases.
	* Cons: Requires manual implementation and testing.
4. `window.toString()`: Converts arrays to strings using the `toString()` method.
	* Pros: No dependencies, easy to implement.
	* Cons: Slower, less accurate.

**Other Alternatives**

Some alternative methods that could be used for comparing arrays include:

1. Using `Array.prototype.every()` or `Array.prototype.some()` for comparison.
2. Using `Set` data structure to compare arrays and ignore duplicates.
3. Implementing a custom equality check using bitwise operators (e.g., `===`, `!==`, etc.).

These alternatives may have different trade-offs in terms of performance, accuracy, and implementation complexity.

I hope this explanation helps!

Latest run results:

Run details: (Test run date: 6 months ago)

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

Browser/OS: Chrome 124 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
_.isEqual	3661634.2 Ops/sec
JSON.stringify	2701091.2 Ops/sec
equals	4835323.0 Ops/sec
equalsIgnoreOrder	2439753.2 Ops/sec
toString	3644854.2 Ops/sec

Related benchmarks:

compare arrays + toString (version: 0)

lodash vs json stringify and other methods

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

Created: 6 months ago by: Guest

Jump to the latest result

_.isEqual

JSON.stringify

equals

equalsIgnoreOrder

toString

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):