Benchmark: Test indexOf vs FindIndex vs include v2

Script Preparation code:

var bigIdList = new Array(15000);
bigIdList.fill({ id: 0 });
bigIdList = bigIdList.map((el) => el.id = Math.floor(Math.random() * 15000))

var test = 7500
var last = 15000

Tests:

Index Of
bigIdList.indexOf(test) !== -1
Find Index
bigIdList.findIndex((item) => item === test)
Includes
bigIdList.includes(test)
Index Of last
bigIdList.indexOf(last) !== -1
Find Index last
bigIdList.findIndex((item) => item === last)
Includes last
bigIdList.includes(last)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Index Of
Find Index
Includes
Index Of last
Find Index last
Includes last

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Index Of	1665439.5 Ops/sec
Find Index	102203.0 Ops/sec
Includes	1670994.5 Ops/sec
Index Of last	953477.7 Ops/sec
Find Index last	38653.7 Ops/sec
Includes last	948863.4 Ops/sec

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

LLMs can make mistakes. Check important info.

**What is being tested?**

The provided benchmark measures the performance of three different methods to search for an element in an array:

1. `indexOf()`: Returns the index of the first occurrence of the specified value, or -1 if not found.
2. `findIndex()`: Returns the index of the first occurrence of the specified value, or -1 if not found. This method is similar to `indexOf()`, but it returns a promise and allows for asynchronous execution.
3. `includes()`: Returns a boolean indicating whether an element with the specified value exists in the array.

**Options compared**

The benchmark compares the performance of these three methods on two different values:

* The first value (`test`) is used to search for itself in the large array, simulating a typical use case.
* The second value (`last`) is used to search for itself at the end of the array, which can be a common edge case.

**Pros and Cons**

* `indexOf()`:
	+ Pros: Wide support across browsers, efficient performance for most use cases.
	+ Cons: Returns -1 on failure, which may not always be desirable. Can return NaN if the input is NaN or Infinity.
* `findIndex()`:
	+ Pros: Allows for asynchronous execution and promises, can be useful in certain scenarios. Has improved performance compared to `indexOf()` in some cases.
	+ Cons: Returns a promise, which can add extra complexity to the code. May not be suitable for all use cases due to its asynchronous nature.
* `includes()`:
	+ Pros: Efficient performance, returns a boolean value, and is supported across browsers. Can simplify code compared to using `indexOf()` or `findIndex()`.
	+ Cons: May have slower performance compared to `indexOf()` for large arrays.

**Library used**

None of the methods mentioned in this benchmark rely on any external libraries. However, it's worth noting that some JavaScript engines and environments might have custom implementations or optimizations for these methods.

**Special JS feature or syntax**

The `includes()` method was introduced in ECMAScript 2019 (ES10) as a part of the standard specification. It provides an efficient way to check if an element exists in an array without having to use indexing or searching algorithms.

**Other alternatives**

There are other methods that can be used for similar purposes, such as:

* Using `Array.prototype.some()` or `Array.prototype.every()`
* Implementing a custom binary search algorithm
* Using a library like Lodash with its `includes()` function

However, the three methods mentioned in this benchmark ( `indexOf()`, `findIndex()`, and `includes()`) are generally considered to be among the most efficient and widely supported approaches.

Related benchmarks:

Test indexOf vs FindIndex vs include v2 (version: 1)

Comparing performance of: Index Of vs Find Index vs Includes vs Index Of last vs Find Index last vs Includes last

Created: 3 months ago by: Registered User

Jump to the latest result

Index Of

Find Index

Includes

Index Of last

Find Index last

Includes last

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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