Benchmark: .map.includes vs .find with shuffle

Script Preparation code:

  var numberOfData = 1e3
    data = [];
    for (let i = 0; i <= numberOfData; i++) {
      data[i] = { test: `my-${numberOfData - i}` };
    }
data = _.shuffle(data);

Tests:

.map.includes
let arrayIds = data.map((el) => el.test); for (let i = 0; i <= numberOfData; i++) { arrayIds.includes(`my-${numberOfData - i}`); }
.find
for (let i = 0; i <= numberOfData; i++) { data.find((el) => el.test === `my-${numberOfData - i}`); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
.map.includes
.find

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 break down the provided benchmark and explain what is being tested.

**Benchmark Overview**

The benchmark compares two approaches to find elements in an array: `.map.includes` and `.find`. The test data consists of 1,000 objects with a "test" property, which contains a string value.

**Options Compared**

The two options being compared are:

1. `.map.includes`: This method returns `true` if the specified value is present in the mapped array.
2. `.find`: This method returns the first element that satisfies the provided condition.

**Pros and Cons of Each Approach**

**`.map.includes`**:

Pros:

* Efficient for large arrays, as it uses a single iteration over the data.
* Can be faster due to its optimized implementation.

Cons:

* Requires additional memory allocation for creating the mapped array.
* May have performance issues if the input array is very large or sparse.

**`.find`**:

Pros:

* Does not require additional memory allocation.
* Can be useful when you need to perform additional operations on the found element.

Cons:

* Typically slower than `.map.includes` due to the overhead of finding a single element in a large array.
* May have performance issues if the input array is very large or sparse.

**Other Considerations**

* Both approaches use iteration over the data, which means they can benefit from optimized JavaScript engine implementations.
* The benchmark's use of `_.shuffle(data)` suggests that the order of elements does not matter, and both options should perform similarly.

**Library Used**

The `_` library is used for shuffling the array data. It is a popular utility library that provides various functions for working with arrays, strings, and objects.

**Special JavaScript Features or Syntax**

There are no special JavaScript features or syntax used in this benchmark. The code uses standard JavaScript methods and syntax.

**Alternative Benchmarks**

Other alternatives to measure performance could include:

* `Array.prototype.some()` instead of `.map.includes`
* Using a different data structure, such as an object with multiple properties
* Incorporating other factors that might affect performance, like sorting or filtering the array

Keep in mind that these alternative benchmarks would require additional setup and modifications to the code.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/113.0

Browser/OS: Firefox 113 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
.map.includes	290.8 Ops/sec
.find	50.6 Ops/sec

Related benchmarks:

.map.includes vs .find with shuffle (version: 0)

Comparing performance of: .map.includes vs .find

Created: one year ago by: Guest

Jump to the latest result

.map.includes

.find

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