Benchmark: Some vs. Filter vs. indexOf vs includes1123123123

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 27 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**Benchmark Definition**

The benchmark is designed to compare the performance of three different methods for checking if an element exists in an array:

1. `Array.some()`
2. `Array.filter()`
3. `Array.indexOf()` (note: this method returns -1 if the element is not found, so it's slightly slower than the other two)
4. `Array.includes()`

**Script Preparation Code**

The script preparation code generates two arrays with 10,000 random integers each:

* `hasZero`: an array of integers between 0 and 999
* `withoutZero`: an array of integers between 1 and 1000

This code is executed before running the benchmark.

**Html Preparation Code**

There is no HTML preparation code provided.

**Test Cases**

Each test case uses a specific JavaScript expression to check if an element exists in one of the two arrays. The expressions are:

* `Array.some()`: `hasZero.some(v => v === 0)` or `withoutZero.some(v => v === 0)`
* `Array.filter()`: `hasZero.filter(v => v === 0)` or `withoutZero.filter(v => v === 0)`
* `Array.indexOf()`: `hasZero.indexOf(0) > -1` or `withoutZero.indexOf(0) > -1`
* `Array.includes()`: `hasZero.includes(0)` or `withoutZero.includes(0)`

**Library and Special JS Features**

There are no external libraries used in the benchmark. However, note that `Array.prototype.some()` and `Array.prototype.filter()` use a feature called "strict mode" (enabled by default in modern browsers), which can affect performance.

**Pros and Cons of Each Approach**

Here's a brief overview:

1. **Array.some()**
	* Pros: more concise, flexible
	* Cons: may be slower due to the iteration and callback function overhead
2. **Array.filter()**
	* Pros: more concise, flexible
	* Cons: may be slower than `some()` because of the additional filtering step
3. **Array.indexOf()**
	* Pros: simple, fast (but returns -1 if not found)
	* Cons: slower than the other two methods due to the linear search
4. **Array.includes()**
	* Pros: more concise, faster than `indexOf()` and `some/ filter()` for this specific use case
	* Cons: may be slower than `some()` and `filter()` because of the additional lookup

**Other Alternatives**

In addition to these methods, there are other ways to check if an element exists in an array:

* Using a custom function with a linear search
* Using a library like Lodash's `some` and `filter`
* Using a language-specific feature or extension (e.g., Rust's `contains` method)

However, the provided benchmark is specifically designed to compare these four methods, making it a good starting point for evaluating performance characteristics of each approach.

Latest run results:

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

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

Browser/OS: Chrome 104 on Windows

View result in a separate tab

Test name	Executions per second
Array.some	466401.0 Ops/sec
Array.filter	101924.7 Ops/sec
Array.indexOf	972620.6 Ops/sec
Array.Includes	3825943.0 Ops/sec

Related benchmarks:

Some vs. Filter vs. indexOf vs includes1123123123 (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 27 days ago):