Benchmark: Some vs. Filter vs. indexOf vs. includes vs reduce

Script Preparation code:

var hasZero = [];
var withoutZero = [];
for (var i = 0; i < 100; 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(0) : withoutZero.includes(0);
Array.reduce
var tempResult = !!Math.round(Math.random()) ? hasZero.reduce((pre, curr) => pre || curr === 0, false) : withoutZero.reduce((pre, curr) => pre || curr === 0, false);

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.reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.some	15618159.0 Ops/sec
Array.filter	8743960.0 Ops/sec
Array.indexOf	32282058.0 Ops/sec
Array.includes	32446706.0 Ops/sec
Array.reduce	27186264.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of four different methods for searching and filtering arrays: `Array.includes`, `Array.indexOf`, `Array.filter`, and `Array.reduce`. The test case uses two random arrays, `hasZero` and `withoutZero`, which are populated with integers between 0 and 1000.

**Test Cases**

Each test case measures the performance of one specific method. Here's a brief explanation of each:

1. **Array.includes**: This method checks if an array contains a specified value (in this case, 0) within a reasonable tolerance (using `Math.round(Math.random())`).
2. **Array.indexOf**: This method returns the index of the first occurrence of a specified value (in this case, 0) in the array.
3. **Array.filter**: This method creates a new array containing only the elements that pass a test provided as a function (in this case, `v => v === 0`).
4. **Array.reduce**: This method applies a function to each element of an array (in this case, `(pre, curr) => pre || curr === 0, false`) and returns a single value.

**Performance Comparison**

The benchmark measures the performance of each test case in terms of executions per second. The results show that:

* `Array.includes` is the fastest method, with an average of around 1150035 executions per second.
* `Array.indexOf` is slower than `Array.includes`, but still relatively fast, with an average of around 894245 executions per second.
* `Array.filter` and `Array.reduce` are significantly slower, with averages around 506995 and 502544 executions per second, respectively.

**Library Usage**

None of the test cases explicitly use any libraries or external dependencies. However, it's worth noting that the `Math.round(Math.random())` expression used in each test case is a built-in JavaScript function that uses the Math library.

**Special JavaScript Features/Syntax**

The benchmark uses some special JavaScript features and syntax:

* The `some()` and `filter()` methods are part of the Array prototype.
* The `indexOf()` method is also part of the Array prototype.
* The `reduce()` method is part of the Array prototype.
* The use of `Math.random()` generates random numbers for testing.

**Alternatives**

If you're interested in exploring alternative approaches, here are a few options:

* **Manual iteration**: Instead of using built-in array methods, you could write your own loop-based implementation to search and filter arrays.
* **Third-party libraries**: There are many third-party libraries available that provide optimized implementations for array operations. For example, Lodash provides `some()`, `filter()`, `indexOf()`, and `reduce()` functions with custom options.
* **Native code**: In some cases, you might be able to write native code using assembly or a similar language to achieve better performance.

Keep in mind that these alternatives may not provide the same convenience and readability as using built-in array methods.

Related benchmarks:

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

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

Created: 2 years ago by: Guest

Jump to the latest result

Array.some

Array.filter

Array.indexOf

Array.includes

Array.reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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