Benchmark: array indexOf vs includes vs some

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 = ['banana', 'sausage', 'jesus']

Tests:

IndexOf
array.indexOf('sausage') > -1
Includes
array.includes('sausage')
some
array.some(v => v === 'sausage')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
IndexOf
Includes
some

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/128.0.0.0 Safari/537.36

Browser/OS: Chrome 128 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
IndexOf	18015830.0 Ops/sec
Includes	18479624.0 Ops/sec
some	18625442.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark you provided tests the performance of three different JavaScript methods for determining if an array contains a specific value. The methods under scrutiny are `indexOf`, `includes`, and `some`. Let's break them down:

### Methods Tested:

1. **array.indexOf('sausage') > -1**
   - **Description**: The `indexOf` method searches the array for the specified element and returns its index. If the element is found, the index is `0` or greater; if not, it returns `-1`. In this benchmark, the result is compared to `-1`.
   - **Pros**:
     - Supported in all browsers, making it widely compatible.
     - Versatile as it also retrieves the index, which can be useful for other operations.
   - **Cons**:
     - Returns `-1` for index checks, which requires an additional comparison to achieve a boolean value.
     - May have performance drawbacks with larger arrays compared to other methods due to iteration.

2. **array.includes('sausage')**
   - **Description**: This method checks if an array contains a specific element and returns a boolean value (`true` or `false`).
   - **Pros**:
     - Clear and straightforward syntax for checking existence.
     - Provides a direct boolean response, making it neater for conditional checks.
   - **Cons**:
     - Slightly less performant than `some` and `indexOf` in some older engines; however, this has improved in modern environments.

3. **array.some(v => v === 'sausage')**
   - **Description**: The `some` method tests whether at least one element in the array passes the test implemented by the provided function. It implements a predicate function that checks equality against the value being searched for.
   - **Pros**:
     - Highly flexible since the predicate can be customized for more complex checks (e.g., checking against conditions, objects).
     - Returns as soon as a match is found, which can improve performance for larger datasets in some cases.
   - **Cons**:
     - May introduce slight overhead from the function call, especially if the predicate function is complex or heavy.

### Benchmark Results Summary:

From the latest benchmark results, we observe the following performances:
- **Best performing method**: `some` with approximately 18.6 million executions per second.
- **Second**: `includes` at around 18.5 million executions per second.
- **Third**: `indexOf` with roughly 18 million executions per second.

### Additional Considerations:

1. **Browser Compatibility**: 
   - `indexOf` is older and fully supported across all browsers, making it a safe option for cross-browser functionality.
   - `includes` was introduced in ES6 (ES2015) and has good support in modern browsers, but might be an issue with legacy systems.
   - `some` also belongs to ES5 and is widely supported.

2. **Performance in Real Applications**: 
   - The performance differences are relatively minor for small arrays, but as the size of the array increases or in critical performance conditions (e.g., within loops or high-frequency calls), the choice of method can significantly impact the application's responsiveness and efficiency.

3. **Other Alternatives**: 
   - **Using a Set**: If you're checking the existence of elements frequently, converting the array to a Set can improve the lookup time (`set.has(value)`).
   - **For loops and manual indexing**: In scenarios where performance is paramount, custom loops with early exits (`for` or `forEach`) can sometimes outperform built-in methods depending on the situation.

In conclusion, while all three methods serve the fundamental purpose of checking for existence within arrays, their performance characteristics and usage contexts vary. Choosing between them should be guided not only by performance but also by the readability and maintainability of the code in relation to the specific application needs.

Related benchmarks:

array indexOf vs includes vs some (version: 1)

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

Comparing performance of: IndexOf vs Includes vs some

Created: one month ago by: Guest

Jump to the latest result

IndexOf

Includes

some

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):