Benchmark: Array Intersection vs. Set Intersection vs. Lodash part 5

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

Tests:

Javascript Set intersection
const firstSet = new Set(first); const secondSet = new Set(second); firstSet.filter(item => secondSet.has(item));
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

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares three approaches to find the intersection between two arrays or sets:

1. **JavaScript Array Intersection**: Using the `filter` method on an array.
2. **Lodash Intersection**: Using the `_intersection` function from the Lodash library.
3. **Set Intersection**: Using a built-in Set data structure.

**Options Compared**

The benchmark compares these three approaches for finding the intersection between two arrays or sets, with varying sizes (100 vs 20 elements). The options are compared in terms of performance (executions per second).

**Pros and Cons of Each Approach**

1. **JavaScript Array Intersection**:
	* Pros: Easy to implement, no additional dependencies required.
	* Cons: May be slower than other approaches for large datasets due to the overhead of filtering.
2. **Lodash Intersection**:
	* Pros: Fast and efficient, provides a standardized way to perform set operations.
	* Cons: Requires an additional dependency (the Lodash library), may not be suitable for small projects or performance-critical code.
3. **Set Intersection**:
	* Pros: Fastest approach, most memory-efficient, ideal for large datasets.
	* Cons: May not be suitable for smaller datasets due to the overhead of creating a Set.

**Lodash Library**

The benchmark uses Lodash version 4.17.5. Lodash is a popular JavaScript utility library that provides a set of functional programming helpers. The `_intersection` function takes two arrays as input and returns an array containing only the elements present in both arrays.

**Special JS Features/Syntax**

None mentioned in this benchmark, but it's worth noting that some modern JavaScript features like `const` and arrow functions are not explicitly mentioned either.

**Other Alternatives**

If you need a faster Set intersection implementation, you could consider using a library like Fast-Set or SetInterval. If you prefer to implement the Set intersection from scratch, you can use the `Map` data structure instead of Sets.

In summary, this benchmark provides a clear comparison between three approaches for finding intersections between arrays and sets, highlighting the trade-offs between ease of implementation, performance, and dependencies required.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36

Browser/OS: Chrome 102 on Linux

View result in a separate tab

Test name	Executions per second
Javascript Set intersection	0.0 Ops/sec
Lodash intersection	317247.6 Ops/sec
Javascript Array intersection	103712.8 Ops/sec

Related benchmarks:

Array Intersection vs. Set Intersection vs. Lodash part 5 (version: 0)

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

Created: 2 years ago by: Guest

Jump to the latest result

Javascript Set intersection

Lodash intersection

Javascript Array intersection

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