Benchmark: Lodash vs. Set Methods Intersection

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 = [1, 3, 4, 5, 7];
var second = [2, 3, 5, 6];

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 set methods intersection
const firstSet = new Set(first); const secondSet = new Set(second); firstSet.intersection(secondSet);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Javascript Set intersection
Lodash intersection
Javascript set methods 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.

**Benchmark Overview**

The MeasureThat.net benchmark tests the performance of three different approaches to find the intersection between two sets in JavaScript:

1. **Lodash**: uses the `intersection` function from the Lodash library, a popular utility library for functional programming tasks.
2. **JavaScript Set Methods Intersection**: utilizes the built-in `Set` data structure and its methods (`has`, `size`, `forEach`) to perform the intersection operation.
3. **Native JavaScript Intersect Functionality**: uses the newly introduced `Intersect()` function in modern browsers, which allows for efficient set operations.

**Approach Options: Pros and Cons**

1. **Lodash Intersection**
	* Pros:
		+ Well-tested and widely used library
		+ Easy to use and understand
	* Cons:
		+ Adds an external dependency (Lodash)
		+ May introduce overhead due to the library's complexity
2. **JavaScript Set Methods Intersection**
	* Pros:
		+ Utilizes built-in data structure and methods, reducing external dependencies
		+ Simple and straightforward implementation
	* Cons:
		+ May require more manual effort and understanding of set operations
		+ Performance may vary depending on browser support for `Intersect()` function
3. **Native JavaScript Intersect Functionality**
	* Pros:
		+ Optimized for performance, as it's a native function
		+ Reduces external dependencies
	* Cons:
		+ Currently only supported in modern browsers (e.g., Chrome 128 and later)
		+ May require additional setup or polyfills for older browsers

**Library Overview**

The Lodash library is a popular utility library for functional programming tasks, including set operations. In this benchmark, the `intersection` function is used to find the intersection between two sets.

**JavaScript Set Methods Intersection**

In this approach, the built-in `Set` data structure and its methods (`has`, `size`, `forEach`) are used to perform the intersection operation. The code creates two sets from the input arrays, then uses a `filter` method to remove elements that are not present in the second set.

**Native JavaScript Intersect Functionality**

The newly introduced `Intersect()` function is used to find the intersection between two sets. This function takes advantage of the optimized performance and reduced dependencies compared to using Lodash or manual set operations.

**Other Alternatives**

Some alternative approaches that could be considered for this benchmark include:

* Using the `Array.prototype.filter()` method with a custom implementation
* Utilizing other libraries like underscore.js (another utility library) or a dedicated set intersection library
* Implementing a custom set intersection algorithm using bitwise operators

However, these alternatives may not provide the same level of performance and simplicity as the three approaches tested in this benchmark.

Latest run results:

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

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

Browser/OS: Chrome 128 on Windows

View result in a separate tab

Test name	Executions per second
Javascript Set intersection	2451421.0 Ops/sec
Lodash intersection	3423790.5 Ops/sec
Javascript set methods intersection	2976630.8 Ops/sec

Related benchmarks:

Lodash vs. Set Methods Intersection (version: 0)

Comparing performance of: Javascript Set intersection vs Lodash intersection vs Javascript set methods intersection

Created: 2 months ago by: Guest

Jump to the latest result

Javascript Set intersection

Lodash intersection

Javascript set methods 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):