Benchmark: Lodash intersection vs plain js

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/lodash/4.16.0/lodash.min.js"></script>

Script Preparation code:

var arrFull = ['past','present','future']
var arrOne = ['past']

Tests:

Intersection - Full
_.intersection(arrFull, arrFull)
aaaaa
arrFull.filter(x => arrFull.includes(x))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Intersection - Full
aaaaa

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the benchmark and its components.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark test case on MeasureThat.net. The test compares two approaches: using the Lodash library's `intersection` function versus writing a plain JavaScript implementation.

In this specific test case, we have three main entities:

1. **Benchmark Definition**: This is the code snippet that defines the benchmark. In this case, it contains two benchmark definitions:
	* `_.intersection(arrFull, arrFull)`: This uses the Lodash library's `intersection` function to find the common elements between two arrays (`arrFull`) and returns an array of those common elements.
	* `arrFull.filter(x => arrFull.includes(x))`: This is a plain JavaScript implementation that filters the original array `arrFull` using the `includes` method to check if each element exists in the array.
2. **Script Preparation Code**: This is the code snippet that prepares the environment for the benchmark test. In this case, it defines two arrays: `arrFull` and `arrOne`. The latter is not used in the benchmark but can be considered a setup for the first benchmark definition (`_.intersection(arrFull, arrFull)`).
3. **Html Preparation Code**: This is an external JavaScript library that provides the Lodash functionality, including the `intersection` function. In this case, it's included via a CDN (Content Delivery Network).

**Options compared**

The two options being compared are:

1. Using the Lodash library's `intersection` function
2. Writing a plain JavaScript implementation using the `filter` method

**Pros and Cons of each approach:**

**Lodash Library (`_.intersection(arrFull, arrFull)`)**

Pros:

* Faster execution time due to optimized native code
* Reduced memory allocation and garbage collection
* Easier to read and maintain, as it's a well-tested library function

Cons:

* Dependence on an external library (Lodash)
* Potential overhead of including the library via CDN

**Plain JavaScript Implementation (`arrFull.filter(x => arrFull.includes(x))`)**

Pros:

* No dependence on an external library
* Simple and easy to understand for developers familiar with JavaScript basics

Cons:

* Slower execution time due to manual array manipulation
* More memory allocation and garbage collection overhead
* May be less efficient than the optimized Lodash implementation

**Other considerations:**

* The `filter` method has a higher number of iterations compared to the Lodash `intersection` function, which may impact performance.
* The plain JavaScript implementation requires more careful handling of edge cases (e.g., empty arrays, duplicate elements) that might not be accounted for by the Lodash library.

**Special JS features or syntax:**

The benchmark uses the ES6 `includes` method and arrow functions (`x => arrFull.includes(x)`). These features are relatively recent additions to JavaScript and may not be supported in older browsers or environments.

**Library descriptions:**

* **Lodash**: A popular utility library for JavaScript that provides a wide range of functional programming helpers, including the `intersection` function. Lodash is designed to provide concise and efficient solutions for common problems.

In summary, this benchmark tests the performance difference between using an optimized external library (`_.intersection`) versus writing a plain JavaScript implementation. The results will indicate which approach is faster and more suitable for specific use cases.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:104.0) Gecko/20100101 Firefox/104.0

Browser/OS: Firefox 104 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Intersection - Full	4358417.5 Ops/sec
aaaaa	9395202.0 Ops/sec

Related benchmarks:

Lodash intersection vs plain js (version: 0)

Comparing performance of: Intersection - Full vs aaaaa

Created: 4 years ago by: Guest

Jump to the latest result

Intersection - Full

aaaaa

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