Benchmark: Some vs. Filter vs. indexOf vs 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;
Array.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
Array.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 break down the provided benchmark and explain what is being tested.

**Overview**

The benchmark consists of four test cases that compare the performance of different methods to filter or search for a specific value in an array: `Array.some`, `Array.filter`, `Array.indexOf`, and `Array.includes`.

**Test Cases**

1. **`Array.some`**: This method returns `true` if at least one element in the array satisfies the provided condition.
2. **`Array.filter`**: This method creates a new array with all elements that satisfy the provided condition.
3. **`Array.indexOf`**: This method returns the index of the first element in the array that matches the specified value, or -1 if no such element exists.
4. **`Array.includes`**: This method checks if an element is present in the array and returns `true` if it does.

**Comparison**

The benchmark compares the performance of each of these methods on two arrays: `hasZero` (contains 10,000 random integers between 0 and 999) and `withoutZero` (contains 10,000 random integers between 0 and 1000).

**Options Compared**

* `Array.some`
	+ **Pros**: Simple to implement, flexible, can be used for filtering or searching.
	+ **Cons**: May have poor performance due to the use of `for...in` loops in older browsers, may not work as expected with large arrays.
* `Array.filter`
	+ **Pros**: Creates a new array, preserving the original array's integrity, less memory-intensive than `some`.
	+ **Cons**: More complex implementation, can be slower due to the creation of a new array.
* `Array.indexOf`
	+ **Pros**: Fast and efficient for finding a single element in an array, often used as a fallback when other methods are too slow.
	+ **Cons**: Returns the index of the first match, may not work correctly if there's no match, can be slower than `some` or `filter`.
* `Array.includes`
	+ **Pros**: Simple and intuitive implementation, fast and efficient for searching an array.
	+ **Cons**: May have poor performance in older browsers due to the use of `for...in` loops, may not work correctly with large arrays.

**Library Used**

None of these methods rely on a specific library. However, it's worth noting that some implementations might use internal libraries or optimizations that are not exposed in the standard specification.

**Special JS Features/Syntax**

There are no special JavaScript features or syntax used in this benchmark. The code is written using standard JavaScript and does not utilize any modern features like async/await, promises, or destructuring.

**Alternatives**

Other methods that could be used for filtering or searching arrays include:

* `Array.prototype.forEach`: This method executes the provided callback function once for each element in the array.
* Custom loops: Writing a custom loop to iterate over the array and check for elements can also be an option.
* Other libraries or frameworks: Depending on the specific requirements, other libraries like Lodash or Underscore.js might provide more efficient or convenient methods for filtering or searching arrays.

Keep in mind that this benchmark focuses specifically on comparing the performance of `Array.some`, `Array.filter`, `Array.indexOf`, and `Array.includes`.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0

Browser/OS: Firefox 131 on Windows

View result in a separate tab

Test name	Executions per second
Array.some	29931.2 Ops/sec
Array.filter	17870.8 Ops/sec
Array.indexOf	284000.0 Ops/sec
Array.includes	280805.0 Ops/sec

Related benchmarks:

Some vs. Filter vs. indexOf vs Includes (version: 0)

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

Created: 2 years ago by: Guest

Jump to the latest result

Array.some

Array.filter

Array.indexOf

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