Benchmark: JS Array IndexOf vs find vs findIndex vs includes

Script Preparation code:

var arr = [];
var i = 0;

while (i <= 1E5) arr[i] = i++;

Tests:

find
const item = arr.find(item => item == 1E5);
findIndex
const index = arr.findIndex(item => item == 1E5);
indexOf
const index = arr.indexOf(1E5);
includes
const included = arr.includes(1E5);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
find
findIndex
indexOf
includes

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:95.0) Gecko/20100101 Firefox/95.0

Browser/OS: Firefox 95 on Windows

View result in a separate tab

Test name	Executions per second
find	1775.5 Ops/sec
findIndex	1792.7 Ops/sec
indexOf	7024.1 Ops/sec
includes	4738.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of four different methods to find an element in an array:

1. `indexOf`
2. `includes`
3. `findIndex`
4. `find`

These methods are used to search for a specific value within an array.

**Options Compared**

Each method has its own way of searching for the element, and we'll compare their performance:

* **`indexOf`**: This method returns the index of the first occurrence of the specified value within the array. If the value is not found, it returns `-1`.
* **`includes`**: This method checks if the array includes the specified value without returning an index.
* **`findIndex`**: Similar to `indexOf`, but this method only returns the index of the first occurrence of the specified value in a strictly increasing sequence. If no such element is found, it returns `-1`.
* **`find`**: This method returns the first element that satisfies the provided testing function.

**Pros and Cons**

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

* **`indexOf`**:
	+ Pros: Fast and efficient for small arrays.
	+ Cons: May be slower for large arrays, as it has to iterate through the entire array.
* **`includes`**:
	+ Pros: Simple and straightforward implementation.
	+ Cons: May not be as efficient as `indexOf` or `findIndex`, especially for large arrays.
* **`findIndex`**:
	+ Pros: Similar performance to `indexOf` for small arrays and may be more efficient than `includes`.
	+ Cons: Requires the array elements to be in a strictly increasing sequence, which can be a limitation.
* **`find`**:
	+ Pros: Allows for more flexible testing conditions (e.g., finding the first element that meets a certain condition).
	+ Cons: May have higher overhead due to its more complex implementation.

**Library and Purpose**

None of these methods rely on external libraries. They are native JavaScript functions.

**Special JS Feature or Syntax**

* None of these methods use special JavaScript features or syntax beyond basic JavaScript programming.

**Other Alternatives**

For searching arrays, other alternatives include:

* `Array.prototype.some()` for a more concise implementation
* Using `Binary Search` for very large arrays (not tested in this benchmark)
* Using external libraries like Lodash or Ramda for array manipulation and filtering

The provided benchmark should give an idea of how these methods compare in terms of performance, but keep in mind that actual performance may vary depending on the specific use case and environment.

Related benchmarks:

JS Array IndexOf vs find vs findIndex vs includes (version: 0)

Comparing performance of: find vs findIndex vs indexOf vs includes

Created: 3 years ago by: Guest

Jump to the latest result

find

findIndex

indexOf

includes

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