Benchmark: Array Intersection vs. Set Intersection vs. Lodash - big

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(10000)].map(it => ~~(Math.random() * 1000));
var second = [...Array(2220)].map(it => ~~(Math.random() * 1000));

Tests:

Javascript Set intersection
const firstSet = new Set(first); const secondSet = new Set(second); new Set([...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 25 days ago):

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark measures the performance of three approaches to find the intersection between two arrays or sets in JavaScript:

1. Using built-in `Set` data structure
2. Using Lodash library's `intersection` function
3. Using array filtering with `includes`

**Options Compared**

* **Built-in Set Intersection**: This approach uses the built-in `Set` data structure to create a set from each input array, and then filters out elements that are not present in the other set using the `has` method.
* **Lodash Intersection**: This approach uses Lodash library's `intersection` function to find the intersection between two arrays. The function takes two arguments, an array and another array, and returns a new array with only the elements that are common to both input arrays.
* **JavaScript Array Intersection**: This approach uses array filtering with the `includes` method to find the intersection between two arrays.

**Pros and Cons**

* **Built-in Set Intersection**:
	+ Pros: Fast, efficient, and easy to implement.
	+ Cons: Requires JavaScript's built-in `Set` data structure, which might not be available in all environments (e.g., older browsers).
* **Lodash Intersection**:
	+ Pros: Easy to use, well-tested, and widely supported.
	+ Cons: Adds an external dependency (Lodash library), which can increase payload size and make the code harder to maintain.
* **JavaScript Array Intersection**:
	+ Pros: Easy to implement, no additional dependencies required.
	+ Cons: Might be slower than built-in `Set` intersection due to the overhead of filtering.

**Library: Lodash**

Lodash is a popular JavaScript library that provides a set of utility functions for various tasks, including array manipulation. The `intersection` function is used to find the common elements between two arrays.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntax used in this benchmark. All approaches use standard JavaScript methods and data structures.

**Other Alternatives**

* For a more lightweight approach, you could also use a simple loop-based solution to find the intersection between two arrays, without using built-in `Set` or Lodash.
* Another alternative is to use a library like `fast-set` which provides a faster implementation of sets compared to JavaScript's built-in `Set`.
* If performance is critical and compatibility with older browsers is not an issue, you could consider using a Just-In-Time (JIT) compiler like V8 or SpiderMonkey to optimize the code for maximum performance.

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/102.0.0.0 Safari/537.36

Browser/OS: Chrome 102 on Windows

View result in a separate tab

Test name	Executions per second
Javascript Set intersection	3344.4 Ops/sec
Lodash intersection	4073.3 Ops/sec
Javascript Array intersection	106.3 Ops/sec

Related benchmarks:

Array Intersection vs. Set Intersection vs. Lodash - big (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 25 days ago):