Benchmark: Array Intersection vs. natife JS Set Intersection vs. Lodash part 3

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var first = [...Array(100)].map(it => ~~(Math.random() * 1000));
var second = [...Array(20)].map(it => ~~(Math.random() * 1000));

var firstSet = new Set(first);
var secondSet = new Set(second);

Tests:

Javascript Set intersection
new Set(firstSet.intersection(secondSet));
Lodash intersection
_.intersection(first, second)
Javascript Array intersection
first.filter(it => second.includes(it))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Javascript Set intersection
Lodash intersection
Javascript Array intersection

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36

Browser/OS: Chrome 125 on Windows

View result in a separate tab

Test name	Executions per second
Javascript Set intersection	4939615.5 Ops/sec
Lodash intersection	639068.8 Ops/sec
Javascript Array intersection	267099.3 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Purpose**

The primary goal of this benchmark is to compare the performance of three different approaches for finding the intersection of two arrays or sets in JavaScript:

1. Native JavaScript Set Intersection
2. Lodash Intersect Function
3. Array Filtering with `includes()` method

**Native JavaScript Set Intersection**

In the provided script preparation code, two random arrays (`first` and `second`) are generated using `Array.prototype.map()`. The script then creates two sets from these arrays using the `Set` constructor.

The benchmark test case uses this native set intersection approach: `new Set(firstSet.intersection(secondSet))`.

**Lodash Intersect Function**

The benchmark includes a reference to Lodash, which is a popular utility library for JavaScript. Specifically, the Lodash `_.intersection()` function is used in the second test case: `_.intersection(first, second)`.

**Array Filtering with `includes()` method**

In the third test case, the benchmark uses array filtering with the `includes()` method to find the intersection: `first.filter(it => second.includes(it))`.

**Comparison of Approaches**

Now, let's compare these approaches:

* **Native JavaScript Set Intersection**: This approach is likely to be the fastest because sets are optimized for efficient lookups and intersections. Sets are implemented as hash tables, which allow for constant-time lookups.
* **Lodash Intersect Function**: Lodash's `_.intersection()` function uses a similar approach to native set intersection but with additional overhead due to the library's initialization and parsing of the input arrays.
* **Array Filtering with `includes()` method**: This approach is likely to be slower than the native set intersection and Lodash approaches because it involves iterating over one array (`second`) for each element in the other array (`first`), which requires more computations.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Native JavaScript Set Intersection**:
	+ Pros: Fast, efficient, and optimized for sets.
	+ Cons: May not work well with non-set data structures.
* **Lodash Intersect Function**:
	+ Pros: Convenient, readable code, and easy to use.
	+ Cons: Additional library overhead and potential performance impact.
* **Array Filtering with `includes()` method**:
	+ Pros: General-purpose approach that works with any array.
	+ Cons: Slower than native set intersection or Lodash approaches.

**Other Considerations**

When choosing an approach, consider the specific requirements of your use case:

* If you're working with sets or need to perform frequent lookups, use the native JavaScript Set Intersection approach.
* If readability and convenience are more important than performance, use the Lodash Intersect Function.
* If you need a general-purpose solution that works with any array, use the Array Filtering with `includes()` method.

Keep in mind that these benchmarks may not be representative of all scenarios, and your specific use case may have different requirements.

Related benchmarks:

Array Intersection vs. natife JS Set Intersection vs. Lodash part 3 (version: 0)

Comparing performance of: Javascript Set intersection vs Lodash intersection vs Javascript Array intersection

Created: one year ago by: Guest

Jump to the latest result

Javascript Set intersection

Lodash intersection

Javascript Array intersection

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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