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>

​x
 
​
<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;
}

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

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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 6 months 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

Autogenerated LLM Summary (model llama3.2:3b, generated 5 months ago):

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:

Using Lodash's _.intersection() method
A custom optimized function 1 (named "Best")
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

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

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: 6 months ago by: Registered User

Jump to the latest result

Lodash _.intersection()