Benchmark: Native filter includes vs_.isEqual 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)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native filter includes
_.isEqual

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance is a complex task, and MeasurThat.net provides a valuable platform for benchmarking.

The provided JSON represents a benchmark test case with two individual tests: "native filter includes" and "_isEqual". We'll break down what's being tested in each case.

**Native Filter Includes**

This test compares the performance of using `filter()` and `includes()` methods on an array of strings. The benchmark prepares arrays `foo` and `bar`, both containing objects with `id` and `name` properties.

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

The test case expects the arrays to be of equal length and contains no duplicates. The `filter()` method is used with a callback function that checks if an element exists in the `xyz` array using `includes()`. If the conditions are not met, the test fails.

**Pros and Cons:**

*   **Pros:**
    *   Native JavaScript methods are generally faster since they don't rely on external libraries.
    *   This approach is easy to understand and implement for developers familiar with JavaScript arrays.
*   **Cons:**
    *   The `filter()` method can be slower due to the overhead of creating a new array.
    *   The use of `includes()` can lead to unnecessary iterations if the array contains many duplicates.

**_.isEqual**

This test compares the performance of using Lodash's `_isEqual` function on sorted arrays. The benchmark prepares arrays `foo` and `bar`, both containing objects with `id` properties.

```javascript
const abc = foo.map((x) => x.id).sort();
const xyz = bar.map((x) => x.id).sort();
_.isEqual(abc, xyz);
```

The test case sorts the arrays using the `sort()` method and then uses `_isEqual` to compare them. If the arrays are not equal, the test fails.

**Pros and Cons:**

*   **Pros:**
    *   Lodash's `_isEqual` function provides a convenient way to compare complex data structures.
    *   This approach is often faster than native JavaScript methods for large datasets due to the optimized implementation of `_isEqual`.
*   **Cons:**
    *   The test relies on an external library, which may introduce additional overhead or dependencies.
    *   The use of `sort()` can be slower if the arrays are already sorted.

**Library and Special JS Features**

In this benchmark, Lodash's `_isEqual` function is used. `_isEqual` provides a way to compare complex data structures, including arrays, objects, and sets. It also supports various comparison strategies, such as strict equality or loose equality.

There are no special JavaScript features or syntax used in these tests.

**Alternatives**

If you want to run this benchmark on your own, here's an example of how you could write the test cases:

```javascript
// Native filter includes
const abc = [...foo].map(x => x.id).filter(id => !bar.find(y => y.id === id));
abc.length === xyz.length && abc.filter(id => !xyz.includes(id)).length === 0;

// _.isEqual
const sortedFoo = [...foo].sort((a, b) => a.id - b.id);
const sortedBar = [...bar].sort((a, b) => a.id - b.id);
const isEqual = require('lodash/isEqual');
isEqual(sortedFoo, sortedBar);
```

Note that this implementation does not include the overhead of loading Lodash and may be slower than using the library.

Related benchmarks:

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

Test

Comparing performance of: native filter includes vs _.isEqual

Created: 4 years ago by: Guest

Jump to the latest result

native filter includes

_.isEqual

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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