Benchmark: SET has/get vs ARR find/some/indexOf + ARR splice/set search array as found

Script Preparation code:

function func(a, b) {  
  return 0.5 - Math.random();
} 

var a = Array.from({length: 1000}).map((_, i) => i)
var arrA0 = a.toSorted(func);
var arrA1 = a.toSorted(func);
var arrA2 = a.toSorted(func);

var arrS0 = new Set(a.map((_, i) => i).toSorted(func));
var arrS1 = new Set(a.map((_, i) => i).toSorted(func));


const tenItemsToFind = () => a.toSorted(func).slice(0, 10);
var list = a.slice(0,10).map(() => Array.from({length: 1000}).map((_, i) => i).toSorted(func).slice(0, 100))

var listLast = a.map(v => v).toSorted(func);
var listLastTwo =a.map(v => v).toSorted(func);

var aclone = a.map(v=>v);
var aclonetwo = a.map(v=>v);

Tests:

ARRincludes
list.forEach( arr => arr.forEach( a => arrA0.includes(a)))
Arr find
list.forEach( arr => arr.forEach( a => arrA0.find(v => v === a)))
SET has
list.forEach(arr => arr.forEach(a => arrS0.has(a)))
Arr some
list.forEach( arr => arr.forEach( a => arrA0.some(v => v === a)))
Arr indexOf
list.forEach( arr => arr.forEach( a => arrA1.indexOf(a)))
Arr sort + index
list.forEach( arr => arr.forEach( a => arrA2[a]))
Arr presorted with remove - splice
listLast.forEach(v => { let b = aclone[v]; aclone.splice(v, 1); })
Arr presorted with remove - set
listLastTwo.forEach(v => { let b = aclonetwo[v]; aclonetwo[v] = null; aclonetwo = aclonetwo.filter(Boolean) })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
ARRincludes
Arr find
SET has
Arr some
Arr indexOf
Arr sort + index
Arr presorted with remove - splice
Arr presorted with remove - set

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

**Overview**

The provided benchmark is designed to compare the performance of different approaches for searching and manipulating arrays in JavaScript. The test cases focus on various operations such as includes, find, some, indexOf, and sorting.

**Test Cases**

1. **ARRincludes**: Measures the execution time of `arr.forEach(arr => arr.forEach(a => arrA0.includes(a)))`. This test case tests the performance of using `includes()` method to search for an element in a sorted array.
2. **Arr find**: Tests the performance of using `find(v => v === a)` method to find an element in a sorted array.
3. **SET has**: Compares the performance of using `Set` data structure with `has()` method to search for an element.
4. **Arr some**: Measures the execution time of `arr.forEach(a => arrA0.some(v => v === a))`. This test case tests the performance of using `some()` method to search for at least one element in a sorted array.
5. **Arr indexOf**: Tests the performance of using `indexOf()` method to find an element in a sorted array.
6. **Arr sort + index**: Compares the performance of accessing an element by its index after sorting the array.

**Options Compared**

The benchmark compares the following options:

* Using `includes()`, `find()`, and `some()` methods for searching
* Using `has()` method for searching with `Set` data structure
* Accessing elements by their index after sorting

**Performance Observations**

From the provided benchmark results, we can observe that:

* Using `Arr includes()` is relatively fast (around 10-15 ms/s) compared to other methods.
* `Arr find()` and `Arr some()` are slower than `includes()`, but faster than other methods like `has()` for searching with `Set`.
* Accessing an element by its index after sorting (`Arr sort + index`) is relatively slow (around 50-100 ms/s).

**Recommendations**

Based on the benchmark results, we can recommend the following:

* Use `includes()`, `find()`, and `some()` methods for searching in sorted arrays.
* Avoid using `has()` method for searching with `Set` data structure unless it's specifically required by your use case.
* Consider caching or reusing sorted arrays to improve performance when accessing elements by their index.

Keep in mind that these observations are based on a specific benchmark and may not be representative of all scenarios. It's essential to test and optimize your code for specific use cases and requirements.

Latest run results:

Run details: (Test run date: 5 months ago)

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

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
ARRincludes	9165.2 Ops/sec
Arr find	284.4 Ops/sec
SET has	15578.1 Ops/sec
Arr some	286.8 Ops/sec
Arr indexOf	9032.0 Ops/sec
Arr sort + index	29756.0 Ops/sec
Arr presorted with remove - splice	12583.1 Ops/sec
Arr presorted with remove - set	573.7 Ops/sec

Related benchmarks:

SET has/get vs ARR find/some/indexOf + ARR splice/set search array as found (version: 10)

Comparing performance of: ARRincludes vs Arr find vs SET has vs Arr some vs Arr indexOf vs Arr sort + index vs Arr presorted with remove - splice vs Arr presorted with remove - set

Created: 5 months ago by: Registered User

Jump to the latest result

ARRincludes

Arr find

SET has

Arr some

Arr indexOf

Arr sort + index

Arr presorted with remove - splice

Arr presorted with remove - set

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