Benchmark: lodash intersection test vs Set

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/2.4.1/lodash.min.js"></script>

Script Preparation code:

var arr1 = [];
for (var i = 0; i <= 100; i++) { arr1.push({
	id: i,
  text: 'blabla-' + i
}); }

var arr2 = [];
for (var i = 0; i <= 150; i+=2) { arr2.push({
	id: i,
  text: 'blabla-' + i
}); }

Tests:

Lodash
_.intersection(arr1, arr2);
Map
const s = new Set(arr2); arr1.filter(a => s.has(a));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Map

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided JSON represents a JavaScript microbenchmark test created on the MeasureThat.net website. The benchmark compares the performance of two approaches to find the intersection between two arrays: using the Lodash library and creating a Set data structure.

**Lodash Intersection Test**

The first individual test case uses the `_.intersection()` function from the Lodash library, which takes two arrays as input and returns an array containing the elements that are common to both. The benchmark script creates two large arrays (`arr1` and `arr2`) and then calls `_.intersection(arr1, arr2)` to find their intersection.

**Set-Based Intersection**

The second individual test case uses a more traditional approach: creating a Set data structure from the second array (`const s = new Set(arr2);`) and then using the `filter()` method to find elements that are present in both arrays. The benchmark script creates two large arrays (`arr1` and `arr2`) and then calls `arr1.filter(a => s.has(a))` to find their intersection.

**Comparison of Approaches**

Both approaches have pros and cons:

* **Lodash Intersection Test:**
	+ Pros:
		- Simplified code and easy to read.
		- Leverages the optimized implementation of Lodash.
	+ Cons:
		- May incur additional overhead due to the Lodash library.
		- Can be slower for smaller arrays or less common elements.
* **Set-Based Intersection:**
	+ Pros:
		- Can be faster for larger arrays and more common elements, as it uses a Set's efficient lookup.
		- Does not rely on external libraries, reducing overhead.
	+ Cons:
		- More complex code, potentially harder to read and maintain.

**Library: Lodash**

The Lodash library is a popular JavaScript utility library that provides a comprehensive set of functions for various tasks, such as array manipulation, string manipulation, and more. In this benchmark, the `_.intersection()` function is used to find the intersection between two arrays.

**Special JS Feature/Syntax: None**

This benchmark does not use any special JavaScript features or syntax that requires additional explanation.

**Other Alternatives**

If you want to explore alternative approaches for finding array intersections, consider:

* Using `Array.prototype.filter()`, which is a more straightforward and widely supported method.
* Utilizing a library like Moment.js for date manipulation (not applicable in this benchmark).
* Implementing a custom set-based intersection algorithm using bitwise operations or hash tables.

For the Set-Based Intersection approach, you can also use other libraries like `collections` or implement your own custom solution.

Related benchmarks:

lodash intersection test vs Set (version: 0)

Comparing performance of: Lodash vs Map

Created: 3 years ago by: Guest

Jump to the latest result

Lodash

Map

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):