Benchmark: Lodash Intersection with Arrays vs. native with sets vs. native filter with arrays

Script Preparation code:

var arr1 = [];
for (let i = 0; i < 1000; i++) {
  arr1.push(i);
}
arr1 = _.shuffle(arr1);

var arr2 = [];
for (let i = 500; i < 1500; i++) {
  arr2.push(i);
}
arr2 = _.shuffle(arr2);
set1 = new Set(arr1);

Tests:

native arrays
arr1.filter(item => arr2.indexOf(item) > -1);
lodash intersection
_.intersection(arr1, arr2);
native with sets
arr2.filter(item => set1.has(item));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native arrays
lodash intersection
native with sets

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36

Browser/OS: Chrome 132 on Linux

View result in a separate tab

native with sets

69K/s

lodash intersection

12K/s

native arrays

12K/s

View exact numbers

Test name	Executions per second
✓ native with sets	68,794 Ops/sec
lodash intersection	12,252 Ops/sec
native arrays	11,939 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Definition JSON**

The benchmark is defined by two parts:

1. **Script Preparation Code**: This code generates two large arrays (`arr1` and `arr2`) with 1000 and 500 elements, respectively, shuffled using the Lodash `shuffle()` function. These arrays are then used to create a new Set (`set1`) from `arr1`.
2. **Individual Test Cases**: There are three test cases:
	* `native arrays`: This test case uses native JavaScript's `filter()` method on `arr1` with an iterator that checks if each element is present in `arr2`.
	* `lodash intersection`: This test case uses the Lodash library's `intersection()` function to find the common elements between `arr1` and `arr2`.
	* `native with sets`: This test case uses native JavaScript's `filter()` method on `arr2` with an iterator that checks if each element is present in the Set (`set1`) created from `arr1`.

**Options Compared**

The three test cases are comparing different approaches to find common elements between two arrays:

1. **Native Arrays**: Uses native JavaScript's `filter()` method and an iterator that checks for presence in another array.
2. **Lodash Intersection**: Uses the Lodash library's `intersection()` function, which is a higher-order function that takes multiple arguments (arrays) and returns their intersection.
3. **Native with Sets**: Uses native JavaScript's `filter()` method and an iterator that checks for presence in a Set created from another array.

**Pros and Cons of Each Approach**

1. **Native Arrays**:
	* Pros: Fast and lightweight, uses built-in functions.
	* Cons: Can be slow if the arrays are very large, as it needs to iterate over the entire array.
2. **Lodash Intersection**:
	* Pros: Convenient and concise, doesn't require manual iteration.
	* Cons: Requires the Lodash library to be included in the test environment, which may add overhead.
3. **Native with Sets**:
	* Pros: Can be faster for large datasets, as Set lookups are O(1) on average.
	* Cons: Requires creating a new Set from one of the arrays, which can be slower than native array operations.

**Library and Purpose**

The Lodash library is a popular utility library that provides various functions to simplify common tasks. In this case, the `intersection()` function is used to find the common elements between two arrays.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax mentioned in this benchmark. The tests only use standard JavaScript features like arrays, Sets, and the `filter()` method.

**Other Alternatives**

If you wanted to implement a similar benchmark without using the Lodash library, you could consider alternative libraries like `lodash-es` (a lighter version of Lodash) or implementing your own intersection function from scratch. Alternatively, you could also use native JavaScript's built-in functions like `Set.prototype.has()` and `Array.prototype.some()` to achieve the same result.

Keep in mind that the choice of approach depends on the specific requirements and constraints of your project.

Lodash Intersection with Arrays vs. native with sets vs. native filter with arrays (version: 0) Benchmark.js

Comparing performance of: `native arrays vs lodash intersection vs native with sets`

Created: 3 years ago by: Guest

Go to the latest result

native arrays

lodash intersection

native with sets

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Lodash Intersection with Arrays vs. native with sets vs. native filter with arrays (version: 0) Benchmark.js

Comparing performance of: native arrays vs lodash intersection vs native with sets

Created: 3 years ago by: Guest

Go to the latest result

native arrays

lodash intersection

native with sets

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: `native arrays vs lodash intersection vs native with sets`