Benchmark: Array Intersection vs. 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));

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 one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

The test is designed to measure the performance of three different approaches for finding intersections between two arrays or sets:

1. **Set Intersection**: This approach uses JavaScript Sets, which are data structures that automatically eliminate duplicates and provide fast lookup times. The Set intersection method takes advantage of this by creating a new set containing only the elements that exist in both input sets.
2. **Lodash Intersection**: This approach relies on the Lodash library, a popular utility library for JavaScript that provides various helper functions. The `intersection` function from Lodash is used to calculate the intersection between two arrays.
3. **Array Intersection**: This approach uses array methods like `filter()` and `includes()` to find the common elements between two arrays.

Now, let's discuss the pros and cons of each approach:

**Set Intersection**

Pros:

* Fast lookup times due to the inherent properties of Sets
* Eliminates duplicates automatically

Cons:

* Requires creating a new set, which can be memory-intensive for large inputs
* May not perform as well on small inputs or when dealing with non-numeric data

**Lodash Intersection**

Pros:

* Easy to implement and understand, thanks to the concise API of Lodash
* Optimized for performance by using optimized algorithms

Cons:

* Requires an external library (Lodash), which may incur additional latency
* May not be suitable for very large inputs or memory-constrained environments

**Array Intersection**

Pros:

* No external libraries required, making it a lightweight solution
* Can be easily implemented using standard JavaScript methods

Cons:

* May require more computational resources due to the filtering and includes checks
* May not perform as well on small inputs or when dealing with non-numeric data

Now, let's talk about the library used in this benchmark: Lodash. Lodash is a popular utility library that provides various helper functions for tasks like array manipulation, string processing, and more. The `intersection` function from Lodash is specifically designed to calculate the intersection between two arrays.

As for special JS features or syntax, there are none mentioned explicitly in the provided code snippets. However, it's worth noting that the use of arrow functions (`=>`) and template literals (`\r\n`) is a common pattern in modern JavaScript.

To achieve similar results, you can try using alternative libraries like `lodash` (of course!), but also consider implementing the array intersection approach using standard JavaScript methods or exploring other alternatives like:

* Using `Array.prototype.reduce()` to find intersections
* Utilizing a library like `fast-integer-set` for optimized set operations
* Implementing your own optimized algorithms for finding intersections

Keep in mind that performance differences between these approaches may be subtle, and the choice ultimately depends on your specific use case, performance requirements, and personal preferences.

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 131 on Android

View result in a separate tab

Test name	Executions per second
Javascript Set intersection	248688.0 Ops/sec
Lodash intersection	429530.6 Ops/sec
Javascript Array intersection	84256.3 Ops/sec

Related benchmarks:

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

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

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