Benchmark: array indexOf vs includes vs some vs Set has

HTML Preparation code:

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

Script Preparation code:

var array = ['x26','x52','x164','x2844','x2869','x2870','x2873',,'x2876','x2962','x2980','x2986','x3179','x3243','x3248','x3288','x3289','x3322','x3333','x3397','x3417','x3423','banana', 'sausage', 'jesus']

Tests:

some
array.some(v => v === 'sausage')
Set
new Set(array).has('sausage')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
some
Set

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmarking test cases.

**What is being tested?**

MeasureThat.net is testing the performance of different approaches to find if an array contains a specific value:

1. `array.indexOf(v => v === 'sausage')`: This uses the `indexOf` method with a callback function.
2. `new Set(array).has('sausage')`: This uses a `Set` data structure created from the array, and then checks for existence using the `has` method.

**Options compared**

The test compares two options:

1. **Callback-based `indexOf`**: This approach uses the `indexOf` method with a callback function that takes an element of the array as an argument.
2. **Set-based `has`**: This approach creates a `Set` data structure from the array and then checks for existence using the `has` method.

**Pros and Cons**

1. **Callback-based `indexOf`**:
	* Pros: Widely supported, simple to implement.
	* Cons: May be slower than other approaches due to the need to iterate over the array.
2. **Set-based `has`**:
	* Pros: Can be faster for large datasets since sets only store unique elements.
	* Cons: Requires additional memory allocation for the set data structure.

**Other considerations**

When using these approaches, it's essential to note that:

1. The callback function in `indexOf` may not return immediately if the value is not found, as it will continue searching the array. This can lead to slower performance.
2. Sets are generally faster than arrays when it comes to membership testing, but they require more memory and can be slower for very large datasets.

**Library used**

In this benchmark, `lodash` (version 4.17.5) is included as a dependency in the HTML preparation code. It's likely being used elsewhere in the test suite, but not directly relevant to these specific test cases.

**Special JavaScript feature or syntax**

There are no special features or syntaxes being tested in these benchmarks. The focus is on comparing two common approaches for array membership testing.

Now, let's look at some alternative approaches that could be included in a benchmark like this:

* **`includes()` method**: This would compare the performance of using the `includes()` method with an iterator function.
* **Native `findIndex()` method**: This would test the performance of using the `findIndex()` method to find the index of the first occurrence of a value in the array.
* **Custom implementation using binary search**: This would involve implementing a custom binary search algorithm to find the first occurrence of a value in the array.

These alternative approaches could provide additional insights into the performance characteristics of different membership testing methods.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.45 Safari/537.36

Browser/OS: Chrome 96 on Windows

View result in a separate tab

Test name	Executions per second
some	5337528.0 Ops/sec
Set	584537.2 Ops/sec

Related benchmarks:

array indexOf vs includes vs some vs Set has (version: 0)

performance comparison of ways to find if an array contains a value

Comparing performance of: some vs Set

Created: 2 years ago by: Guest

Jump to the latest result

some

Set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 25 days ago):