Benchmark: Lodash intersection vs nested finds

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 isEmpty and intersection
_.isEmpty(_.intersection(arr1, arr2))
Nested finds
Boolean( arr1.find((el1) => arr2.find((el2) => { return ( el1 === el2 ); }) ) );

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash isEmpty and intersection
Nested finds

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 provided benchmark definition and options compared.

**Benchmark Definition:**

The test measures two approaches to check if an element is present in one array within another:

1. **Lodash Intersection**: Uses the `_.intersection` function from the Lodash library to find common elements between two arrays.
2. **Nested Finds**: Iterates through each element of the first array and checks if it exists in the second array using the `find` method.

**Options Compared:**

* **Lodash Intersection**: Uses the `_.intersection` function, which takes two arrays as input and returns an array with common elements.
* **Nested Finds**: Uses a nested loop structure to iterate through each element of the first array and checks if it exists in the second array using the `find` method.

**Pros and Cons:**

1. **Lodash Intersection**:
	* Pros:
		+ Efficient, as it uses optimized algorithms for finding common elements.
		+ Easy to use, as it's a built-in function with clear documentation.
	* Cons:
		+ Adds additional overhead due to the use of an external library.
		+ May be slower than native JavaScript implementations if not used correctly.
2. **Nested Finds**:
	* Pros:
		+ No additional overhead, as it only relies on native JavaScript methods.
		+ Can be optimized further by using techniques like early returns or caching.
	* Cons:
		+ More complex to implement and maintain, especially for large datasets.
		+ May require more computational resources due to the nested loop structure.

**Library:**

The Lodash library is used in this benchmark. It's a popular utility library that provides a wide range of functions for tasks such as array manipulation, functional programming, and string manipulation.

**Special JS Feature/Syntax:**

This benchmark does not use any special JavaScript features or syntax beyond what is commonly available in modern browsers. However, it does rely on the `find` method, which is a part of the ECMAScript standard.

**Other Alternatives:**

If you're looking for alternative approaches to this problem, consider:

1. **Using `Array.prototype.filter()`**: Instead of finding common elements, you can use `filter()` to create a new array with elements that satisfy a condition.
2. **Implementing your own algorithm**: You could write a custom algorithm using native JavaScript methods to find common elements between two arrays.

Here's an example implementation using `filter()`:
```javascript
function hasCommonElement(arr1, arr2) {
  return arr1.some((el1) => arr2.includes(el1));
}
```
This approach is simpler than the nested finds method but may not be as efficient for large datasets.

Related benchmarks:

Lodash intersection vs nested finds (version: 0)

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

Comparing performance of: Lodash isEmpty and intersection vs Nested finds

Created: 2 years ago by: Guest

Jump to the latest result

Lodash isEmpty and intersection

Nested finds

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