Benchmark: Lodash intersection vs some+includes

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).length > 0
some+includes
arr1.some(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 one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark that compares two approaches to check if there is an element from one array in another.

**Script Preparation Code**

The script preparation code generates two arrays, `arr1` and `arr2`, each with 1000 random elements of length 5 (e.g., strings or numbers). The purpose of this code is to create a large dataset for the benchmark.

```javascript
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 have at least 1 element in common
arr1[arr1.length - 1] = arr2[0];
```

**Html Preparation Code**

The HTML preparation code includes a reference to the Lodash library (version 4.17.5) via a CDN.

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

**Benchmark Definition**

The benchmark definition consists of two individual test cases:

1. `_.intersection(arr1, arr2).length > 0`: This test case uses Lodash's `intersection` function to find the common elements between `arr1` and `arr2`. The result is compared to an empty array.
2. `arr1.some(el => arr2.includes(el))`: This test case uses a simple iterative approach to check if any element in `arr1` is present in `arr2`.

**Comparison of Approaches**

The two approaches are:

* **Lodash's `intersection` function**: This approach uses a library (Lodash) to perform the comparison. The pros include:
	+ Concise and readable code
	+ Optimized for performance by leveraging native JavaScript algorithms
	+ Reduces the risk of common mistakes or edge cases
* **Simple iterative approach (`arr1.some(...)`)**: This approach does not use a library. The pros include:
	+ Easy to understand and implement
	+ No dependency on external libraries
	+ Can be more flexible for custom implementations

However, the simple iterative approach also has cons:

* More code to write and maintain
* May introduce common mistakes or edge cases if not implemented carefully
* May not be optimized for performance compared to a dedicated library like Lodash

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks such as array manipulation, object transformation, and more. In this benchmark, the `intersection` function is used to find common elements between two arrays.

The purpose of using Lodash in this benchmark is to demonstrate how a well-written, optimized library can improve performance compared to a simple iterative approach.

**Special JS Feature: Spread Operator (`...`)**

The spread operator is not explicitly mentioned as a special feature in the provided code. However, it's worth noting that the `some()` method uses the spread operator internally to iterate over the elements of an array.

In modern JavaScript, the spread operator is a concise way to create a new array from an existing one or an array-like object. It's commonly used in array methods like `filter()`, `map()`, and `reduce()`.

**Alternatives**

Other alternatives for benchmarking similar scenarios could include:

* Using a different library (e.g., underscore.js, Moment.js) that provides similar functionality to Lodash.
* Implementing the comparison logic from scratch without relying on external libraries.
* Using a testing framework like Jest or Mocha to create and run microbenchmarks.

Keep in mind that each approach has its pros and cons, and the choice of alternative will depend on the specific requirements and constraints of the project.

Latest run results:

Run details: (Test run date: 11 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash intersec	5917.4 Ops/sec
some+includes	245.7 Ops/sec

Related benchmarks:

Lodash intersection vs some+includes (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: 6 years ago by: Registered User

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 one month ago):