Benchmark: Lodash intersection vs some+includes2

HTML Preparation code:

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

Script Preparation code:

function makeid(len = 5) {
  var text = "";
  var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

  for (let i = 0; i < len; i++)
    text += possible.charAt(Math.floor(Math.random() * possible.length));

  return text;
}

var arr1 = []
var arr2 = []

for (let i = 0; i < 1000; i++) {
	arr1.push(makeid())
  	arr2.push(makeid())
}

// To ensure that both arrays has at least 1 element in common
arr1[arr1.length - 1] = arr2[0]

Tests:

Lodash intersec
_.intersection(arr1, arr2)
some+includes
arr1.filter(el => arr2.includes(el))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash intersec
some+includes

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is being tested?**

The benchmark tests two algorithms to check if there is an element from one array in another:

1. `_.intersection(arr1, arr2)`: This is a function call that uses the Lodash library to find the intersection of two arrays.
2. `arr1.filter(el => arr2.includes(el))`: This is a custom implementation that uses the `filter` method and the `includes` method to achieve the same result.

**Options compared**

The benchmark compares two approaches:

1. **Lodash's `intersection` function**: This function takes two arrays as input and returns an array containing only the elements present in both arrays.
2. **Custom implementation with `filter` and `includes`**: This approach uses the `filter` method to create a new array that includes only the elements from `arr1` that are also present in `arr2`, by calling the `includes` method on each element of `arr1`.

**Pros and cons**

Here's a brief summary:

* **Lodash's `intersection` function**: Pros:
	+ Optimized for performance
	+ Handles edge cases (e.g., empty arrays, single-element arrays)
	+ Easy to use and understand
* Cons:
	+ Adds an additional dependency (the Lodash library)
	+ May have overhead due to the addition of a new function call
* **Custom implementation with `filter` and `includes`**:
	+ Pros:
		- No additional dependencies or overhead
		- Can be optimized for performance by minimizing the number of method calls
	+ Cons:
		- More complex implementation, which may make it harder to understand and maintain
		- May not handle edge cases as well as the Lodash function

**Library: Lodash**

Lodash is a popular JavaScript library that provides a collection of helper functions for common tasks, such as array manipulation, string formatting, and more. In this case, the `intersection` function is used to find the intersection of two arrays.

**Special JS feature: None**

There are no special JavaScript features or syntax being used in this benchmark. The implementation focuses on the comparison of two algorithms.

**Other alternatives**

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

1. **Using `Set` and `intersection`**: You can create two sets from each array using the `Set` constructor and then call the `intersection` method to find the intersection.
2. **Using `map`, `reduce`, and `every`**: You can use these methods to create a new array that includes only the elements present in both arrays.
3. **Implementing your own `intersection` function**: If you're comfortable with low-level optimization, you can implement your own `intersection` function using bitwise operations or other techniques.

Keep in mind that each alternative approach may have its pros and cons, and some might be more suitable for specific use cases than others.

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 intersec	3269.4 Ops/sec
some+includes	159.3 Ops/sec

Related benchmarks:

Lodash intersection vs some+includes2 (version: 0)

This benchmark compares some algorithms to check if there is an element from an array into another

Comparing performance of: Lodash intersec vs some+includes

Created: 2 years ago by: Guest

Jump to the latest result

Lodash intersec

some+includes

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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