Benchmark: Number array indexOf vs includes vs some vs find vs for vs in

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 = [1, 2, 3]

Tests:

IndexOf
array.indexOf(3) !== 1
Includes
array.includes(3)
some
array.some(v => v == 3)
find
array.find(v => v == 3)
for loop
for (let i = 0; i < array.length; i++) { if (array[i] == 3) { return true; } }
in
3 in array

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
IndexOf
Includes
some
find
for loop
in

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the benchmark and its test cases.

**What is being tested?**

MeasureThat.net is testing the performance of different ways to check if an array contains a specific value. The benchmark is comparing the execution time of six methods:

1. `array.indexOf(3) !== 1`
2. `array.includes(3)`
3. `array.some(v => v == 3)`
4. `array.find(v => v == 3)`
5. A manual `for` loop to check if an element exists in the array
6. The `in` operator to check if a value is present in the array

**Options being compared**

The benchmark is comparing the performance of these six methods:

* `indexOf`: returns the index of the first occurrence of the specified value, or -1 if it's not found.
* `includes`: checks if the array contains the specified value.
* `some`: returns true if at least one element in the array matches the specified condition.
* `find`: returns the first element that satisfies the specified condition, or undefined if no elements match.
* Manual `for` loop: uses a traditional loop to iterate through the array and check for the presence of the value.
* `in`: checks if the value is present in the array using the `in` operator.

**Pros and Cons of each approach**

Here's a brief summary of the pros and cons of each approach:

* `indexOf`: Pros: concise, fast. Cons: returns index, not boolean result, can be slower for large arrays.
* `includes`: Pros: easy to read, fast. Cons: can be slower for very small arrays due to overhead.
* `some` and `find`: Pros: concise, flexible. Cons: may return false positives or negatives if the condition is too loose or strict.
* Manual `for` loop: Pros: explicit control, no external dependencies. Cons: verbose, error-prone, slow.
* `in`: Pros: simple, fast. Cons: can be slower for very small arrays due to overhead.

**Library usage**

The benchmark uses Lodash library, which provides the `some` and `find` functions. These functions are often used in functional programming to reduce code duplication and improve readability.

**Special JS features or syntax**

There's no special JavaScript feature or syntax being tested in this benchmark. All test cases use standard JavaScript syntax.

**Alternatives**

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

* Use `Array.prototype.every` instead of `some` for a more concise and expressive way to check if all elements match the condition.
* Use `Array.prototype.reduce` instead of `find` for a more functional programming approach to find the first element that satisfies the condition.
* Consider using a custom implementation for the manual `for` loop, such as using a `while` loop or a recursive function.

Keep in mind that these alternatives might not be directly comparable to the original benchmark, as they may use different optimization strategies or trade-offs.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36 OPR/92.0.0.0 (Edition beta)

Browser/OS: Opera 92 on Windows 8.1

View result in a separate tab

Test name	Executions per second
IndexOf	5019572.5 Ops/sec
Includes	5322172.5 Ops/sec
some	5276220.5 Ops/sec
find	5251752.5 Ops/sec
for loop	887793.4 Ops/sec
in	5300101.5 Ops/sec

Related benchmarks:

Number array indexOf vs includes vs some vs find vs for vs in (version: 0)

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

Comparing performance of: IndexOf vs Includes vs some vs find vs for loop vs in

Created: 3 years ago by: Guest

Jump to the latest result

IndexOf

Includes

some

find

for loop

in

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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