Benchmark: Some vs. Filter vs. indexOf vs. Includes vs. Find vs. findIndex performance

Script Preparation code:

var hasZero = [];
var withoutZero = [];
for (var i = 0; i < 10000; i++) {
  hasZero.push(Math.floor(Math.random() * 1000));
  withoutZero.push(Math.floor(Math.random() * 1000) + 1)
}

Tests:

Array.some
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.some(v => v === 0);
Array.filter
var tempResult = !!Math.round(Math.random()) ? hasZero.filter(v => v === 0) : withoutZero.filter(v => v === 0);
Array.indexOf
var tempResult = !!Math.round(Math.random()) ? hasZero.indexOf(0) > -1 : withoutZero.indexOf(0) > -1;
Array.includes
var tempResult = !!Math.round(Math.random()) ? hasZero.includes(v => v === 0) : withoutZero.includes(v => v === 0);
Array.find
var tempResult = !!Math.round(Math.random()) ? hasZero.find(v => v === 0) : withoutZero.find(v => v === 0);
Array.findIndex
var tempResult = !!Math.round(Math.random()) ? hasZero.findIndex(v => v === 0) > -1 : withoutZero.findIndex(v => v === 0) > -1;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.some
Array.filter
Array.indexOf
Array.includes
Array.find
Array.findIndex

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 22 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Array.some	69193.7 Ops/sec
Array.filter	25953.2 Ops/sec
Array.indexOf	756328.1 Ops/sec
Array.includes	391370.0 Ops/sec
Array.find	68671.7 Ops/sec
Array.findIndex	91202.9 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 22 days ago):

LLMs can make mistakes. Check important info.

The benchmark provided tests the performance of various JavaScript methods for checking the presence of a value (in this case, zero) within an array. The methods being compared are:

1. **Array.some**
2. **Array.filter**
3. **Array.indexOf**
4. **Array.includes**
5. **Array.find**
6. **Array.findIndex**

### Description of Each Approach

1. **Array.some**:
   - **Usage**: This method tests whether at least one element in the array passes the test implemented by the provided function.
   - **Pros**: Efficient for simply checking the existence of a value. Stops iterating through the array once a match is found.
   - **Cons**: Slightly more overhead than methods like `indexOf` because it involves executing a callback for each element.

2. **Array.filter**:
   - **Usage**: This method creates a new array with all elements that pass the test provided by the callback function.
   - **Pros**: Useful when you need to retrieve all matching elements.
   - **Cons**: Always creates a new array, which may have significant performance implications, particularly for large datasets. It does not short-circuit; it evaluates all elements before returning.

3. **Array.indexOf**:
   - **Usage**: Returns the first index at which a given value can be found in the array, or -1 if it is not present.
   - **Pros**: Straightforward and performant for checking existence; a simple check returns the index or -1.
   - **Cons**: Only checks for primitive values and does not support complex checks directly unless combined with other logic.

4. **Array.includes**:
   - **Usage**: Determines whether an array includes a certain value among its entries.
   - **Pros**: More readable than `indexOf` when checking for existence, as it only requires a value and returns a boolean.
   - **Cons**: Slightly slower than `indexOf` in certain cases, particularly for larger datasets.

5. **Array.find**:
   - **Usage**: Returns the value of the first element in the provided array that satisfies the provided testing function.
   - **Pros**: Allows for more complex conditions to be specified via a callback function.
   - **Cons**: Like `some`, it will iterate through all elements until a match is found, adding overhead.

6. **Array.findIndex**:
   - **Usage**: Similar to `find`, but returns the index of the first element that satisfies the testing function.
   - **Pros**: Combines the benefits of `find` with knowing the index, which can be useful in many applications.
   - **Cons**: Also involves a callback, which may result in performance issues compared to pure existence checks.

### Benchmark Execution and Results

The benchmark results indicate that:

- **Array.indexOf** performed with the highest number of executions per second, suggesting it is the most efficient method in this context.
- **Array.includes** followed, highlighting its improved readability while still maintaining good performance.
- **Array.findIndex** showed moderate performance, while **Array.some** also performed well, indicating that these methods are effective for existence checks.
- **Array.find** had lower performance, likely due to its primary function of retrieving the element rather than merely checking existence.
- **Array.filter** displayed the least performance, primarily because it processes all elements and allocates a new array.

### Conclusion and Alternatives

In summary, if the main goal is to check for the existence of a value, `Array.indexOf` or `Array.includes` are the optimal choices based on performance. For scenarios requiring validation against a condition, `Array.some` provides a good balance of readability and efficiency.

Alternative approaches for performance-sensitive code could also include:
- **Custom loops** (e.g., `for` or `forEach`): May yield better performance in very specific cases, such as when avoiding function callbacks.
- **Typed Arrays**: In scenarios where numerical data is processed, using Typed Arrays can enhance performance due to lower overhead.

Ultimately, the choice of method depends on the specific needs of the application, including performance requirements and code maintainability.

Related benchmarks:

Some vs. Filter vs. indexOf vs. Includes vs. Find vs. findIndex performance (version: 1)

Comparing performance of: Array.some vs Array.filter vs Array.indexOf vs Array.includes vs Array.find vs Array.findIndex

Created: 22 days ago by: Guest

Jump to the latest result

Array.some

Array.filter

Array.indexOf

Array.includes

Array.find

Array.findIndex

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 22 days ago):