Benchmark: JS find vs indexOf vs inclides

Script Preparation code:

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

Tests:

Array.find
const item = arr.find(item => item == 1E5);
Array.indexOf
const index = arr.indexOf(1E5);
includes
const include = arr.includes(1E5);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.find
Array.indexOf
includes

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Purpose**
The purpose of this benchmark is to compare the performance of three JavaScript methods for finding an element in an array: `find()`, `indexOf()`, and `includes()`.

**Options Compared**

1. **`find()`**: The `find()` method returns the first element in the array that satisfies the provided condition, or `undefined` if no such element is found.
2. **`indexOf()`**: The `indexOf()` method returns the index of the first occurrence of the specified value in the array, or `-1` if it's not found.
3. **`includes()`**: The `includes()` method returns a boolean indicating whether an element with the specified value exists in the array.

**Pros and Cons**

*   **`find()`**:
    *   Pros: Can be more concise and readable for certain use cases, as it returns the actual element instead of its index.
    *   Cons: May have higher overhead due to potentially searching through the entire array, especially when the condition is complex. It also doesn't guarantee that the first found element will match exactly what you're looking for (e.g., if you have two elements with the same value).
*   **`indexOf()`**:
    *   Pros: Generally faster than `find()`, as it only needs to traverse through the array until it finds a matching value. It also returns an index, which can be useful in certain scenarios.
    *   Cons: May return `-1` if the element is not found, and it doesn't guarantee that the first found element will match exactly what you're looking for.
*   **`includes()`**:
    *   Pros: Returns a boolean value immediately, making it suitable for use cases where speed is crucial. It also eliminates the need to iterate through the array until an exact match is found.
    *   Cons: May be slower than `indexOf()` in certain scenarios because it always performs a linear search through the entire array.

**Library and Special Features**

In this benchmark, none of the tested methods directly rely on any external libraries. However, note that both `find()` and `includes()` methods can accept additional parameters (e.g., the initial index for `find()`) to modify their behavior.

**Other Considerations**

1.  **Performance**: When choosing between these methods, consider your specific use case. If you need to find an exact match in a large array, `indexOf()` might be faster. However, if you're looking for a concise and readable way to achieve this, `find()` could be suitable.
2.  **Readability and Maintainability**: Since `find()` can return the actual element, it might make your code more readable when working with simple cases. On the other hand, `indexOf()` provides an index that can simplify indexing operations elsewhere in your code.

**Alternatives**

Other methods you could consider for array searching include:

1.  **`filter()`**: Returns a new array containing all elements that satisfy the provided condition.
2.  **`every()`**, **`some()`**: These methods return boolean values indicating whether all or at least some elements in the array satisfy the given condition, respectively.

In summary, when choosing between `find()`, `indexOf()`, and `includes()`, consider your specific requirements for performance, readability, and maintainability.

Latest run results:

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

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

Browser/OS: Chrome 118 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.find	975.0 Ops/sec
Array.indexOf	18607962.0 Ops/sec
includes	18381262.0 Ops/sec

Related benchmarks:

JS find vs indexOf vs inclides (version: 0)

JS find vs indexOf vs includes

Comparing performance of: Array.find vs Array.indexOf vs includes

Created: one year ago by: Guest

Jump to the latest result

Array.find

Array.indexOf

includes

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