Benchmark: array -> indexOf vs includes vs some vs filter

Script Preparation code:

var array = ['banana', 'sausage', 'jesus']

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
IndexOf
Includes
some
filter

Fastest: N/A

Slowest: N/A

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

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
IndexOf	16982014.0 Ops/sec
Includes	18768168.0 Ops/sec
some	17639126.0 Ops/sec
filter	13822218.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of different methods to check if an array contains a specific value: `indexOf`, `includes`, `some`, and `filter`. The goal is to determine which method is the fastest.

**Options Compared**

The four options are compared as follows:

1.  **`array.indexOf('sausage') === 1`**: This method uses the `indexOf` function to find the index of the first occurrence of `'sausage'` in the array. It then checks if the result is equal to 1, which means the value was found at that index.
2.  **`array.includes('sausage')`**: This method uses the `includes` function to check if the array contains the specified value. If it does, the method returns true; otherwise, it returns false.
3.  **`array.some(v => v === 'sausage')`**: This method uses the `some` function with a callback function that checks each element in the array and returns true as soon as it finds a match. If no match is found after checking all elements, the method returns false.
4.  **`array.filter(v => v === 'sausage').length === 1`**: This method uses the `filter` function to create a new array containing only the elements that match the specified value. It then checks if the length of this new array is equal to 1, which means exactly one element matches.

**Pros and Cons**

Here's a brief overview of the pros and cons for each option:

*   **`array.indexOf('sausage') === 1`**: Pros: Simple and efficient for finding the exact index of an element. Cons: May not be suitable if you need to find all occurrences or check if the array is empty.
*   **`array.includes('sausage')`**: Pros: Concise and easy to read. Cons: May have slower performance compared to `indexOf`, especially for large arrays, due to additional checks.
*   **`array.some(v => v === 'sausage')`**: Pros: Useful when you need to check if any element in the array matches a condition. Cons: Can be slow if the array is very large or contains many matching elements, since it stops iterating as soon as it finds a match.
*   **`array.filter(v => v === 'sausage').length === 1`**: Pros: Suitable for finding all occurrences of an element in the array. Cons: Creates a new array with the filtered results, which can be memory-intensive.

**Library and Special JS Features**

The `includes` function uses a library-like approach to perform string matching. It leverages the browser's built-in support for regular expressions to efficiently search for patterns within strings.

No special JavaScript features are required or mentioned in this benchmark.

**Alternatives**

Other alternatives for performing array checks include:

*   **Using a custom function**: You can create a custom function that loops through the array and performs the necessary checks. This approach gives you more control but may be less efficient.
*   **Using `Array.prototype.every`**: Instead of using `some`, you can use the `every` method to check if all elements in the array match a condition. However, this approach is not suitable for finding any matching elements.
*   **Using `Array.prototype.map` and `Array.prototype.length`**: You can create an array with only the desired elements by mapping over the original array and then checking the length of the resulting array.

Keep in mind that each alternative has its own trade-offs in terms of performance, readability, and memory usage.

Related benchmarks:

array -> indexOf vs includes vs some vs filter (version: 0)

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

Comparing performance of: IndexOf vs Includes vs some vs filter

Created: one year ago by: Guest

Jump to the latest result

IndexOf

Includes

some

filter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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