Benchmark: Some vs. Filter vs. indexOf v includes

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;
includes
var tempResult = !!Math.round(Math.random()) ? hasZero.includes(0) : withoutZero.includes(0)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.some
Array.filter
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 world of JavaScript microbenchmarks.

**Benchmark Overview**

The benchmark tests four different methods to check if an element is present in an array: `some`, `filter`, `indexOf`, and `includes`. The test data consists of two arrays, `hasZero` and `withoutZero`, which are populated with random integers. The arrays have similar elements, but the latter includes a zero.

**Test Case Breakdown**

1. **Array.some**: This method returns true if at least one element in the array satisfies the provided condition. In this case, it checks if any of the elements in `hasZero` or `withoutZero` is equal to 0.
2. **Array.filter**: This method creates a new array with all elements that pass the test implemented by the provided function. In this case, it filters out elements that are not equal to 0 from both arrays.
3. **Array.indexOf**: This method returns the index of the first element in the array that satisfies the provided condition (i.e., is equal to 0). If no such element exists, it returns -1.
4. **includes**: This method checks if an element is present in the array. In this case, it checks if 0 is included in both arrays.

**Comparison of Methods**

Here's a summary of the pros and cons of each approach:

*   `some`:
    *   Pros: Efficient for checking presence of multiple values, simple implementation.
    *   Cons: Returns true as soon as a match is found, might be slow if array size is very large, can be slower than other methods in some cases due to branching.
*   `filter`:
    *   Pros: Allows filtering out all non-matching elements, efficient for small arrays.
    *   Cons: Creates new array, might be slower than direct indexing, more complex implementation.
*   `indexOf`:
    *   Pros: Fastest method overall, works well with large arrays, no branching.
    *   Cons: Returns index only if element is found (returns -1 otherwise), might require additional checks for non-matching elements.
*   `includes`:
    *   Pros: Simple implementation, fast when array size is small.
    *   Cons: Can be slower than direct indexing due to the function call overhead, might be slower than `indexOf` in some cases.

**Library Usage**

The `some`, `filter`, and `indexOf` methods use built-in JavaScript functions. No external libraries are required for this benchmark.

No special JavaScript features or syntax are used in this benchmark.

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.3 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 15 on iOS 15.3.1

View result in a separate tab

Test name	Executions per second
Array.some	13311.9 Ops/sec
Array.filter	27927.7 Ops/sec
Array.indexOf	177300.6 Ops/sec
includes	177641.4 Ops/sec

Related benchmarks:

Some vs. Filter vs. indexOf v includes (version: 0)

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

Created: 2 years ago by: Guest

Jump to the latest result

Array.some

Array.filter

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