Benchmark: lodash vs es6 (intersection)

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/g/lodash@4(lodash.min.js+lodash.fp.min.js)"></script>

Script Preparation code:

var dataset = [...Array(20)].map((v, idx) => idx);
var candidates = [1, 2, 5];

Tests:

lodash
candidates.length === (_.intersection(dataset, candidates)).length
es6
var ds = new Set(dataset); var cs = new Set(candidates); candidates.length === ([...ds].filter(v => cs.has(v))).length;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash
es6

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 its options.

**What is being tested?**

The benchmark is testing two approaches to find the intersection of two arrays: `lodash` (a popular JavaScript utility library) vs ES6 (the standard JavaScript syntax).

The test case uses a small dataset of 20 elements, and a set of candidate values. The goal is to find the number of elements that are common to both the dataset and the candidates.

**Options being compared**

There are two options being compared:

1. **Lodash**: Lodash is a utility library that provides various functions for working with data structures, including arrays. In this case, `_.intersection` is used to find the intersection of the dataset and the candidates.
2. **ES6 (Set)**: ES6 introduces a new way of working with collections using the `Set` object. A Set is an unordered collection of unique values.

**Pros and Cons**

* **Lodash**: Pros:
	+ Well-tested and widely used library
	+ Provides a convenient function for finding intersections
* Cons:
	+ Adds external dependency (library)
	+ May be slower due to the overhead of calling a function from another library
* **ES6 (Set)**: Pros:
	+ Native JavaScript syntax, no external dependencies required
	+ Fast and efficient way to find intersections
* Cons:
	+ Requires knowledge of ES6 features (Sets) for implementation

**Library description**

In this benchmark, the Lodash library is used for its `_.intersection` function. The `_.intersection` function takes two arrays as input and returns a new array containing only the elements that are common to both arrays.

**Special JS feature or syntax**

There isn't any special JavaScript feature or syntax being tested here, but it's worth noting that ES6 introduced several features that improve performance and conciseness in programming, such as Sets. In this case, the Set implementation uses a native JavaScript feature (Sets) without requiring additional libraries.

**Other alternatives**

Other alternatives for finding intersections could include:

* Using `Array.prototype.filter()` or `Array.prototype.some()`
* Implementing your own intersection function using loops
* Using other library functions that provide intersection functionality

However, the ES6 Set approach is a simple and efficient way to find intersections, and Lodash provides a convenient and well-tested solution.

Related benchmarks:

lodash vs es6 (intersection) (version: 0)

Comparing performance of: lodash vs es6

Created: 5 years ago by: Guest

Jump to the latest result

lodash

es6

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