Benchmark: lodash intersect vs filter

HTML Preparation code:

<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.core.js"></script>

Tests:

Lodash
var params = [ "hello", true, 7 ]; var params2 = [ "hello", true, 8 ]; var intersection = _.intersection(params, params2);
spread operator
var params = [ "hello", true, 7 ]; var params2 = [ "hello", true, 8 ]; var intersection = params.filter(param => params2.includes(param));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
spread operator

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark is comparing two approaches to find common elements between two arrays: using Lodash's `intersection` function versus using the spread operator (`...`) with the `includes` method. The test cases are designed to measure the performance difference between these two approaches on a JavaScript engine.

**Lodash Intersection Function**

Lodash is a popular utility library for JavaScript that provides various functions to perform tasks like array manipulation, string manipulation, and more. In this case, the `intersection` function is used to find common elements between two arrays.

The Lodash `intersection` function takes two arrays as input and returns an array containing only the common elements. Here's a brief explanation of how it works:

* The function iterates over the first array and checks if each element exists in the second array.
* If an element is found in both arrays, it is added to the result array.
* The function returns the resulting array with common elements.

**Spread Operator Approach**

The spread operator (`...`) is a new feature introduced in ECMAScript 2015 (ES6) that allows creating a new array by "spreading" an existing array. In this approach, we use the `includes` method to check if each element of the first array exists in the second array.

Here's how it works:

* We iterate over the first array using the `for...of` loop or the spread operator itself.
* For each element, we use the `includes` method to check if it exists in the second array.
* If an element is found in both arrays, we add it to a new array (or modify an existing one).

**Pros and Cons of Each Approach**

**Lodash Intersection Function:**

Pros:

* More readable code
* Easier to maintain and update

Cons:

* Adds additional dependencies (Lodash library)
* May have slower performance compared to native JavaScript approaches

**Spread Operator Approach:**

Pros:

* Native JavaScript implementation, which can be faster
* No additional dependencies required

Cons:

* Less readable code for some developers
* May require more effort to maintain and update

**Other Considerations**

* The benchmark is using a specific version of Lodash (4.17.5), which may impact the results.
* The benchmark is running on Chrome 105, a relatively recent browser version.
* The test cases are designed to measure performance, but other factors like memory usage or error rates might be worth considering in a real-world scenario.

**Alternatives**

If you're interested in exploring alternative approaches, here are some options:

1. Using `Array.prototype.filter()` with `includes()`: This approach is similar to the spread operator approach but uses native JavaScript methods instead of the spread operator.
2. Implementing your own intersection function using a simple loop: This approach would be even more performance-oriented but might require more code and effort to maintain.
3. Using other libraries or frameworks that provide optimized array manipulation functions, such as `Array.prototype.intersection()` in some libraries.

Keep in mind that these alternatives may not offer the same level of readability or ease of use as Lodash's `intersection` function or the spread operator approach.

Latest run results:

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

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

Browser/OS: Chrome 105 on Linux

View result in a separate tab

Test name	Executions per second
Lodash	0.0 Ops/sec
spread operator	12019688.0 Ops/sec

Related benchmarks:

lodash intersect vs filter (version: 0)

Comparing performance of: Lodash vs spread operator

Created: 5 years ago by: Guest

Jump to the latest result

Lodash

spread operator

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):