Benchmark: Lodash Intersection vs. ES6 handle duplicate with set destructuration

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
[...new Set(first.filter((item) => second.includes(item)))];
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

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark compares two approaches to find common elements between two arrays:

1. **Lodash Intersection**: Uses the `_.intersection` function from Lodash library to find the intersection of two arrays.
2. **ES6 filter + Set Deconstruction**: Uses JavaScript's built-in `filter` method to create a new array with only the elements that are present in another array, and then uses destructuring assignment (`[...new Set(...)]`) to extract the unique common elements.

**Options Compared**

The benchmark is comparing two different approaches:

1. **Lodash Intersection**: This approach uses an external library (Lodash) to perform the intersection calculation.
2. **ES6 filter + Set Deconstruction**: This approach relies on JavaScript's built-in functions and features, specifically `filter` method and destructuring assignment.

**Pros and Cons**

### Lodash Intersection

Pros:

* **Faster Execution**: The benchmark results show that Lodash's `_.intersection` function is faster than the ES6 filter + Set Deconstruction approach.
* **Easier to Implement**: Using an external library can simplify the implementation, as it provides a pre-tested and optimized function.

Cons:

* **External Dependency**: Requires loading an additional library (Lodash), which may not be desirable in all situations.
* **Higher Memory Footprint**: The benchmark results show that the Lodash approach uses more memory compared to the ES6 filter + Set Deconstruction approach.

### ES6 filter + Set Deconstruction

Pros:

* **No External Dependency**: This approach relies solely on JavaScript's built-in functions and features, making it a better choice for projects where external libraries are not allowed.
* **Low Memory Footprint**: The benchmark results show that this approach uses less memory compared to the Lodash approach.

Cons:

* **More Complex Implementation**: Implementing this approach requires a good understanding of JavaScript's `filter` method and destructuring assignment.
* **Slower Execution**: The benchmark results show that this approach is slower than the Lodash Intersection approach.

**Library: Lodash**

Lodash (pronounced "lodash") is a popular JavaScript utility library that provides a wide range of functions for tasks such as:

* Array manipulation
* String manipulation
* Object manipulation
* Functional programming utilities

The `_.intersection` function in particular is designed to find the intersection of two arrays, making it a useful tool for this benchmark.

**Special JS Feature/Syntax**

In this benchmark, we're using destructuring assignment (`[...new Set(...)]`) which is a JavaScript feature introduced in ES6 (ECMAScript 2015). This syntax allows us to extract unique elements from an array using the `Set` constructor and then spreading it back into an array.

**Alternatives**

If you need to find common elements between two arrays, other approaches could include:

* Using the `reduce()` method with a accumulator function
* Utilizing the `every()` method in combination with `includes()`
* Implementing a custom solution using loops or recursion

However, the Lodash Intersection approach and the ES6 filter + Set Deconstruction approach are two of the most common and efficient ways to solve this problem.

Related benchmarks:

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

Comparing performance of: Javascript ES6 filter include vs Lodash intersection

Created: 5 years ago by: Guest

Jump to the latest result

Javascript ES6 filter include

Lodash intersection

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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