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

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

Comparing performance of: Javascript Set intersection (larger set first) vs Lodash intersection vs Javascript Array intersection vs Javascript Set intersection (new feature) (larger set first) vs Javascript Set intersection (smaller set first) vs Javascript Set intersection (new feature) (smaller set first) vs Javascript Set intersection (new feature) (smaller set first) (with set init time)

Created: 2 years ago by: Guest

Jump to the latest result

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 (larger set first)
new Set(first.filter(item => secondSet.has(item)));
Lodash intersection
_.intersection(first, second)
Javascript Array intersection
first.filter(it => second.includes(it))
Javascript Set intersection (new feature) (larger set first)
firstSet.intersection(secondSet)
Javascript Set intersection (smaller set first)
new Set(second.filter(item => firstSet.has(item)));
Javascript Set intersection (new feature) (smaller set first)
secondSet.intersection(firstSet)
Javascript Set intersection (new feature) (smaller set first) (with set init time)
const newFirstSet = new Set(first); const newSecondSet = new Set(second); newFirstSet.intersection(newSecondSet)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Javascript Set intersection (larger set first)
Lodash intersection
Javascript Array intersection
Javascript Set intersection (new feature) (larger set first)
Javascript Set intersection (smaller set first)
Javascript Set intersection (new feature) (smaller set first)
Javascript Set intersection (new feature) (smaller set first) (with set init time)

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

Browser/OS: Chrome 122 on Windows

View result in a separate tab

Test name	Executions per second
Javascript Set intersection (larger set first)	69478.7 Ops/sec
Lodash intersection	201604.9 Ops/sec
Javascript Array intersection	68214.1 Ops/sec
Javascript Set intersection (new feature) (larger set first)	1613541.5 Ops/sec
Javascript Set intersection (smaller set first)	317653.8 Ops/sec
Javascript Set intersection (new feature) (smaller set first)	1720664.9 Ops/sec
Javascript Set intersection (new feature) (smaller set first) (with set init time)	171540.5 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 benchmark and its test cases.

**What is tested:**

The benchmark tests different approaches to find the intersection of two sets in JavaScript:

1. **Lodash intersection**: Using the `intersection` function from the Lodash library, which returns an array containing only the elements that are present in both input arrays.
2. **JavaScript Array intersection**: Using the `filter` method with a callback function to create a new array containing only the elements that are present in both input arrays.
3. **JavaScript Set intersection (new feature)**: Using the `has` method on JavaScript Sets, which returns a boolean indicating whether an element is present in the set.
4. **JavaScript Set intersection (new feature) with set init time**: This test case includes an additional step to initialize two separate sets from the input arrays before finding their intersection.

**Options compared:**

The benchmark compares the performance of four different approaches:

1. Lodash intersection
2. JavaScript Array intersection
3. JavaScript Set intersection (new feature)
4. JavaScript Set intersection (new feature) with set init time

**Pros and cons of each approach:**

1. **Lodash intersection**:
	* Pros: Convenient and easy to use, widely supported.
	* Cons: Requires an external library, may have additional overhead due to the library's functionality.
2. **JavaScript Array intersection**:
	* Pros: Lightweight and fast, no external dependencies required.
	* Cons: Requires manual implementation of the filter method, can be less readable.
3. **JavaScript Set intersection (new feature)**:
	* Pros: Native JavaScript support, potentially faster than array-based methods due to set operations' inherent efficiency.
	* Cons: Limited support in older browsers or versions, requires modern JavaScript features.
4. **JavaScript Set intersection (new feature) with set init time**:
	* Pros: Includes an additional step that can help mitigate potential performance issues related to the has method's complexity.
	* Cons: Adds unnecessary overhead due to the initialization of separate sets.

**Other considerations:**

1. **Library usage**: The benchmark uses Lodash as a library, which may not be relevant for all developers or use cases.
2. **Browser support**: Some test cases rely on newer JavaScript features or libraries (e.g., Set operations), which might limit the results' applicability to older browsers.

**Alternatives:**

1. Other libraries like `lodash-es` or `underscore` that offer similar functionality without the original Lodash library's dependencies.
2. Native alternatives using other programming constructs, such as using a custom function with multiple loops and conditional statements instead of Set operations.

Keep in mind that these are just general explanations, and you may want to focus on specific aspects depending on your needs or familiarity with JavaScript.

Related benchmarks: