Benchmark: lodash intersect vs filter3

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
var intersection = _.intersection(arr1, arr2);
spread operator
var intersection = arr1.filter(param => arr2.includes(param));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
spread operator

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 and explain what's being tested.

**Benchmark Overview**

The test measures the performance of two approaches to find the intersection of two arrays: using Lodash's `intersection` function and using the spread operator (`...`) with `Array.prototype.includes`.

**Lodash Intersection**

The first test case uses Lodash's `intersection` function, which takes two arrays as input and returns an array containing only the elements that are common to both. The Lodash library is a popular utility belt for JavaScript developers, providing a wide range of functions for tasks like string manipulation, array manipulation, and more.

In this specific test case, Lodash's `intersection` function is called with two arrays: `arr1` and `arr2`. These arrays are created by generating random strings using the `makeid` function.

**Spread Operator Approach**

The second test case uses the spread operator (`...`) in conjunction with `Array.prototype.includes` to find the intersection of the two arrays. This approach works by creating a new array containing all elements from `arr1`, and then checking each element against `arr2` using `includes`. If an element is found in both arrays, it's included in the resulting intersection.

**Comparison**

The benchmark compares the performance of these two approaches:

* Lodash's `intersection` function
* Spread operator approach with `Array.prototype.includes`

**Pros and Cons**

Here are some pros and cons for each approach:

Lodash's `intersection` function:

Pros:

* High-level, readable API
* Well-tested and optimized

Cons:

* May have performance overhead due to the use of a separate library
* May not be suitable for very large datasets

Spread operator approach:

Pros:

* Fast and lightweight, as it only requires basic array operations
* Can be used in pure JavaScript code without requiring additional libraries

Cons:

* Requires manual implementation of the intersection logic
* May be less readable than Lodash's API

**Other Considerations**

When choosing between these approaches, consider the following factors:

* Performance: If speed is critical, the spread operator approach may be faster due to its lightweight nature.
* Readability: If readability is important, Lodash's `intersection` function may be a better choice.
* Library dependencies: If you're using a separate library for Lodash, you'll need to consider the overhead of loading and initializing that library.

**Alternative Approaches**

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

* Using `Set` objects to find the intersection (e.g., `arr1.set(arr2); arr1.size`).
* Implementing a custom intersection function using bitwise operations.
* Using a different library or framework that provides an optimized implementation of array intersection.

I hope this explanation helps you understand the benchmark and the trade-offs involved in choosing between these two approaches!

Related benchmarks:

lodash intersect vs filter3 (version: 0)

Comparing performance of: Lodash vs spread operator

Created: 3 years ago by: Guest

Jump to the latest result

Lodash

spread operator

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