Benchmark: Native filter includes vs_.isEqual vs JSON stringify Equality Comparison for Shallow Array of Strings.

HTML Preparation code:

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

Script Preparation code:

window.foo = [{id: 1, name: 'suh'}, {id: 2, name: 'asd'}];
window.bar = [{id: 2, name: 'asd'}, {id: 1, name: 'suh'}];

Tests:

native filter includes
const abc = foo.map((x) => x.id) ?? []; const xyz = bar.map((x) => x.id) ?? []; !(abc.length !== xyz.length || abc.filter((id) => !xyz.includes(id)).length > 1);
_.isEqual
const abc = foo.map((x) => x.id).sort(); const xyz = bar.map((x) => x.id).sort(); _.isEqual(abc, xyz)
stringify
JSON.stringify(foo) === JSON.stringify(bar);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native filter includes
_.isEqual
stringify

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript benchmark created on MeasureThat.net, which compares the performance of different approaches for equality comparisons on shallow arrays of strings.

**Script Preparation Code**

The script preparation code sets up two variables: `window.foo` and `window.bar`, both containing shallow arrays of objects with `id` and `name` properties. The purpose of these variables is to serve as input data for the benchmark test cases.

**Html Preparation Code**

The HTML preparation code includes a link to the Lodash library, which provides utility functions that can be used in the benchmark test cases.

**Individual Test Cases**

There are three test cases:

1. **Native filter includes**
This test case compares the performance of using `includes()` with array filtering (i.e., `abc.filter((id) => !xyz.includes(id)).length > 1`) versus a native JavaScript approach that uses `for` loops to iterate over the arrays and compare elements.

**Pros and Cons:**

* **Native filter includes**: This approach is straightforward and easy to read. However, it may be slower due to the overhead of filtering and looping.
* **Using array filtering**: This approach is concise and efficient but may be less readable than the native JavaScript approach.

2. **_.isEqual**
This test case compares the performance of using Lodash's `isEqual()` function versus a simple equality comparison using `===`.

**Pros and Cons:**

* _.isEqual: This approach is concise and easy to read, but it relies on an external library (Lodash). If the library is not available or its implementation varies across browsers, this test case may not be representative of real-world performance.
* Simple equality comparison: This approach is straightforward and does not rely on any external libraries. However, it may be less efficient due to the overhead of comparing each element individually.

3. **stringify**
This test case compares the performance of using `JSON.stringify()` with a simple string concatenation.

**Pros and Cons:**

* JSON.stringify(): This approach is concise and easy to read but may be slower due to the overhead of converting objects to strings.
* String concatenation: This approach is straightforward and does not rely on any external libraries. However, it may be less efficient due to the overhead of creating temporary string variables.

**Special JavaScript Features**

The benchmark test cases use the following special JavaScript features:

* Lodash's `isEqual()` function (Test Case 2)
* JSON.stringify() (Test Cases 3)

These features are not unique to JavaScript and can be found in other programming languages as well. However, their performance implications may vary across different environments.

**Other Alternatives**

If the developers want to explore alternative approaches for equality comparisons on shallow arrays of strings, they could consider the following:

* Using a custom implementation that avoids looping or filtering altogether
* Using a different data structure, such as a Set or a Map, to store and compare elements
* Using a library or framework that provides optimized equality comparison functions (e.g., React's `isEqual()` function)

However, it is essential to note that the performance characteristics of these alternatives may vary depending on the specific use case and environment.

Latest run results:

Run details: (Test run date: 3 years ago)

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

Browser/OS: Chrome 93 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
native filter includes	2904341.5 Ops/sec
_.isEqual	1107591.6 Ops/sec
stringify	535090.8 Ops/sec

Related benchmarks:

Native filter includes vs_.isEqual vs JSON stringify Equality Comparison for Shallow Array of Strings. (version: 0)

Test

Comparing performance of: native filter includes vs _.isEqual vs stringify

Created: 3 years ago by: Guest

Jump to the latest result

native filter includes

_.isEqual

stringify

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