Benchmark: Intersection of multiple arrays | Lodash _.intersection() vs various custom optimized methods

HTML Preparation code:

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

Script Preparation code:

var arr1 = [];
var arr2 = [];
var arr3 = [];
var arr4 = [];

for (i = 0; i < 1000; i++) {
    arr1.push(getRandom());
    arr2.push(getRandom());
    arr3.push(getRandom());
    arr4.push(getRandom());
}

function getRandom() {
    const minimum = 1;
    const maximum = 1000;
    var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
    return randomnumber;
}

Tests:

Lodash _.intersection()
const results = new Set(_.intersection(arr1, arr2, arr3, arr4));
Custom optimized function 1 (Best)
function intersectMultipleArrays(...arrays) { if (arrays.length === 0) return new Set(); // Sort arrays by length to optimize operations arrays.sort((a, b) => a.length - b.length); // Start with the smallest array as the base intersection set let intersection = new Set(arrays[0]); // Iterate over the remaining arrays and filter the intersection for (let i = 1; i < arrays.length; i++) { intersection = new Set(arrays[i].filter(item => intersection.has(item))); // Early exit if intersection is empty if (intersection.size === 0) return new Set(); } // Return the final Set return intersection; } const results = intersectMultipleArrays(arr1, arr2, arr3, arr4);
Custom optimized function 2
const results = new Set( [arr1, arr2, arr3, arr4] .sort((a, b) => b.length - a.length) .reduce((a, b) => a.filter(aValue => b.includes(aValue))) );

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash _.intersection()
Custom optimized function 1 (Best)
Custom optimized function 2

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 break down the provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The benchmark measures the performance of three approaches to find the intersection of multiple arrays:

1. Using Lodash's `_.intersection()` method
2. A custom optimized function 1 (named "Best")
3. Another custom optimized function 2

**What is being tested?**

* The intersection of four large arrays (`arr1`, `arr2`, `arr3`, and `arr4`) containing random integers between 1 and 1000.
* Three different approaches to find the intersection:
	+ Lodash's `_intersection()` method
	+ Custom optimized function 1 (best)
	+ Custom optimized function 2

**Options Compared**

The benchmark compares two custom optimized functions, which are essentially implementations of set intersection. The main differences between these two functions are:

* **Function 1 (Best)**:
	+ Sorts the arrays by length to optimize operations
	+ Iterates over the remaining arrays and filters the intersection using a `Set`
	+ Early exits if the intersection is empty
* **Function 2**:
	+ Uses the `reduce()` method with a filter function to find the intersection
	+ Does not sort the arrays, which might be less efficient for large inputs

**Pros and Cons**

* **Function 1 (Best)**:
	+ Pros: sorts arrays to optimize operations, uses early exit condition, potentially faster performance
	+ Cons: assumes array lengths are comparable, may have extra memory overhead due to sorting
* **Function 2**:
	+ Pros: simpler implementation, no extra memory overhead
	+ Cons: does not sort arrays, which might lead to slower performance for large inputs

**Other Considerations**

* Lodash's `_intersection()` method is a convenient and widely-used solution, but its performance may vary depending on the specific input data.
* The benchmark uses JavaScript's built-in `Set` data structure, which provides efficient set operations.

**Library Used: Lodash**

Lodash is a popular JavaScript library that provides a wide range of utility functions. In this case, the `_intersection()` method is used to find the intersection of multiple arrays. Other useful methods from Lodash include `_.uniq()`, `_.uniqWith()`, and `_.difference()`, which perform similar set operations.

**Special JS Feature: None**

There are no special JavaScript features or syntaxes being tested in this benchmark.

**Alternatives**

Other alternatives for finding the intersection of multiple arrays include:

* Using `Array.prototype.filter()` and accumulating the results
* Using a custom implementation with nested loops and manual memory management
* Utilizing specialized libraries like NumJS or MathJax, which provide optimized set operations

Latest run results:

Run details: (Test run date: one month ago)

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

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
Lodash _.intersection()	8922.4 Ops/sec
Custom optimized function 1 (Best)	10882.7 Ops/sec
Custom optimized function 2	4526.0 Ops/sec

Related benchmarks:

Intersection of multiple arrays | Lodash _.intersection() vs various custom optimized methods (version: 2)

Comparing performance of: Lodash _.intersection() vs Custom optimized function 1 (Best) vs Custom optimized function 2

Created: one month ago by: Registered User

Jump to the latest result

Lodash _.intersection()

Custom optimized function 1 (Best)

Custom optimized function 2

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