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: 2 years 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

Javascript Set intersection

4.9M/s

Lodash intersection

639K/s

Javascript Array intersection

267K/s

View exact numbers

Test name	Executions per second
✓ Javascript Set intersection	4,939,616 Ops/sec
Lodash intersection	639,069 Ops/sec
Javascript Array intersection	267,099 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.

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: 2 years ago by: Guest

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

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: 2 years ago by: Guest

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

Related benchmarks

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