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

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

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: 3 years ago by: Guest

Jump to the latest result

Lodash intersec

some+includes

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