Benchmark: Lodash Intersection vs. ES6 handle duplicate

HTML Preparation code:

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

Script Preparation code:

var first = [1, 3, 3, 4, 5, 5, 7];
var second = [2, 3, 5, 6];

Tests:

Javascript ES6 filter include
const uFirst = Array.from(new Set(first)); uFirst.filter(i => second.includes(i));
Lodash intersection
_.intersection(first, second)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Javascript ES6 filter include
Lodash intersection

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark.

**What is being tested?**

The provided JSON represents two microbenchmarks that compare the performance of JavaScript functions to find common elements in two arrays: `Lodash Intersection` and `ES6 Filter Include`. The benchmarks test how fast each approach can filter an array with duplicate values, given a fixed input array (`first`) and a smaller array containing unique values (`second`).

**Options compared**

The benchmark compares the performance of two approaches:

1. **Lodash Intersection**: This method uses the Lodash library to find the intersection of two arrays, which returns an array of elements that are present in both input arrays.
2. **ES6 Filter Include**: This approach uses a JavaScript filter method with the `includes()` function to filter out elements from `first` that are not present in `second`.

**Pros and Cons of each approach**

* **Lodash Intersection**:
	+ Pros: Lodash provides an optimized implementation, which can be faster than a pure JavaScript solution. It's also more concise and easier to read.
	+ Cons: The benchmark requires including the Lodash library as a dependency, adding overhead.
* **ES6 Filter Include**:
	+ Pros: This approach is lightweight, requiring only the built-in `includes()` function, which is likely faster than importing an external library. It's also more flexible and easier to understand for developers familiar with ES6 syntax.
	+ Cons: The benchmark requires using a filter method, which can be slower than native array operations.

**Library usage**

The test case uses the Lodash library (`lodash.js`) to implement the `intersection()` function. Lodash is a popular utility library that provides various helper functions for tasks like this.

**Special JavaScript feature or syntax**

Neither of the benchmarked approaches relies on any special JavaScript features or syntax. The ES6 filter method is a standard part of the language, and the Lodash library is designed to be compatible with most environments.

**Other alternatives**

If you wanted to implement an alternative solution using only built-in JavaScript functions, you could use methods like `Set` (as shown in the first benchmark definition) or regular expressions. However, these approaches are likely to be slower than the Lodash Intersection and ES6 Filter Include solutions.

To implement a pure JavaScript solution, you could create two sets from the input arrays (`first` and `second`) and then use the `intersection()` method of one of the sets. Alternatively, you could iterate through both arrays using loops and regular expressions to check for presence in the second array.

Keep in mind that while these alternatives can be interesting to explore, they're likely to be slower than the optimized solutions provided by libraries like Lodash or built-in JavaScript functions.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 11_1_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36

Browser/OS: Chrome 88 on Mac OS X 11.1.0

View result in a separate tab

Test name	Executions per second
Javascript ES6 filter include	689961.6 Ops/sec
Lodash intersection	1153159.8 Ops/sec

Related benchmarks:

Lodash Intersection vs. ES6 handle duplicate (version: 0)

Comparing performance of: Javascript ES6 filter include vs Lodash intersection

Created: 3 years ago by: Guest

Jump to the latest result

Javascript ES6 filter include

Lodash intersection

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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