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

Historical Performance Data aggregated from 61 community runs

Desktop Results:

Chrome 51 runs

Lodash intersection

462K/s

Javascript Set intersection

382K/s

Javascript Array intersection

212K/s

Fastest: Lodash intersection (2.2x faster)

View exact numbers

✓ Lodash intersection: 461,848 ops/sec
• Javascript Set intersection: 381,851 ops/sec
• Javascript Array intersection: 211,508 ops/sec

Firefox 5 runs

Javascript Array intersection

428K/s

Lodash intersection

381K/s

Javascript Set intersection

284K/s

Fastest: Javascript Array intersection (1.5x faster)

View exact numbers

✓ Javascript Array intersection: 428,474 ops/sec
• Lodash intersection: 380,733 ops/sec
• Javascript Set intersection: 284,397 ops/sec

Mobile Results:

Chrome 5 runs

Lodash intersection

419K/s

Javascript Set intersection

249K/s

Javascript Array intersection

224K/s

Fastest: Lodash intersection (1.9x faster)

View exact numbers

✓ Lodash intersection: 418,885 ops/sec
• Javascript Set intersection: 248,688 ops/sec
• Javascript Array intersection: 223,875 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: 5 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36

Browser/OS: Chrome 145 on Windows

View result in a separate tab

Javascript Array intersection

580K/s

Lodash intersection

578K/s

Javascript Set intersection

503K/s

View exact numbers

Test name	Executions per second
✓ Javascript Array intersection	579,884 Ops/sec
Lodash intersection	578,464 Ops/sec
Javascript Set intersection	503,256 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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

Go to the latest result

Javascript Set intersection

Lodash intersection

Javascript Array intersection

Historical Performance Data aggregated from 61 community runs

Desktop Results:

Chrome 51 runs

Firefox 5 runs

Mobile Results:

Chrome 5 runs

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. Set Intersection vs. Lodash part 3 (version: 0)

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

Created: 6 years ago by: Guest

Go to the latest result

Javascript Set intersection

Lodash intersection

Javascript Array intersection

Historical Performance Data aggregated from 61 community runs

Desktop Results:

Chrome 51 runs

Firefox 5 runs

Mobile Results:

Chrome 5 runs

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`