Benchmark: Includes vs. IndexOf vs. Filter vs. Find vs. FindIndex vs. Some

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:

Includes
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.includes(v => v === 0);
IndexOf
var tempResult = !!Math.round(Math.random()) ? hasZero.indexOf(0) > -1 : withoutZero.indexOf(0) > -1;
Filter
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.filter(v => v === 0);
Find
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.find(v => v === 0);
FindIndex
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.findIndex(v => v === 0);
Some
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.some(v => v === 0);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Includes
IndexOf
Filter
Find
FindIndex
Some

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 18 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explore what's being tested, the different approaches compared, their pros and cons, and other considerations.

**Benchmark Definition**
The benchmark is designed to compare the performance of different methods for checking if an element exists in an array. The six methods being compared are:

1. `some()`
2. `indexOf()`
3. `filter()`
4. `find()`
5. `findIndex()`
6. `includes()` (introduced in ECMAScript 2019)

**Approaches Compared**
Each test case uses a different approach to check if an element exists in the array.

1. `some()`: The `some()` method returns `true` as soon as it finds at least one element that meets the condition.
2. `indexOf()`: The `indexOf()` method returns the index of the first occurrence of the element, or -1 if it's not found.
3. `filter()`: The `filter()` method creates a new array with all elements that pass the test implemented by the provided function.
4. `find()`: The `find()` method returns the value of the first element in the array that satisfies the providing function.
5. `findIndex()`: Similar to `indexOf()`, but it throws an exception if no elements satisfy the condition.
6. `includes()`: Introduced in ECMAScript 2019, this method returns a boolean indicating whether an element exists in the array.

**Pros and Cons of Each Approach**

1. `some()`:
	* Pros: Efficient when only one element needs to be found, can short-circuit if no elements match.
	* Cons: May not be suitable for large arrays or exact matching requirements.
2. `indexOf()`:
	* Pros: Provides the index of the first occurrence, useful for array manipulation.
	* Cons: Can be slow for large arrays, may not be suitable for exact matching (returns -1 if element is not found).
3. `filter()`:
	* Pros: Creates a new array with filtered elements, can be efficient for large datasets.
	* Cons: Returns an empty array if no elements match the condition, requires additional processing to extract the desired value.
4. `find()`:
	* Pros: Efficiently finds the first matching element, returns undefined if not found.
	* Cons: May not be suitable for exact matching requirements (returns the first matching element).
5. `findIndex()`:
	* Pros: Provides the index of the first occurrence, throws an exception if no elements satisfy the condition.
	* Cons: Can be slow for large arrays, may not be suitable for exact matching requirements.
6. `includes()`:
	* Pros: Efficiently checks if an element exists in the array, returns a boolean value.
	* Cons: May not be suitable for exact matching requirements (returns true as soon as it finds one match).

**Library and Purpose**
The `some()` method uses the Array.prototype.some() function, which is part of the ECMAScript standard. The purpose of this function is to return a boolean indicating whether at least one element in the array meets the condition.

Similarly, the other methods use their respective Array.prototype functions:

* `indexOf()`: Array.prototype.indexOf()
* `filter()`: Array.prototype.filter()
* `find()`: Array.prototype.find()
* `findIndex()`: Array.prototype.findIndex()
* `includes()`: Introduced in ECMAScript 2019, its implementation is not part of the standard, but rather a new function provided by modern JavaScript engines.

**Special JS Features or Syntax**
The benchmark uses the following special JS features:

* Arrow functions (e.g., `v => v === 0`)
* Template literals (e.g., `!!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.includes(v => v === 0)`)

These features are not specific to any particular JavaScript engine or version, but rather a part of the modern JavaScript language.

**Other Considerations**
When choosing an approach for checking if an element exists in an array, consider factors such as:

* Performance: `includes()` is often the fastest and most efficient option.
* Exact matching requirements: `indexOf()`, `findIndex()`, or custom implementation may be necessary.
* Array manipulation: `indexOf()` or custom implementation may be suitable.

In summary, the benchmark provides a comprehensive comparison of different methods for checking if an element exists in an array. By understanding the pros and cons of each approach, developers can choose the most efficient solution for their specific use case.

Latest run results:

Run details: (Test run date: 6 months ago)

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

Browser/OS: Chrome 124 on Windows

View result in a separate tab

Test name	Executions per second
Includes	1089834.0 Ops/sec
IndexOf	1243770.2 Ops/sec
Filter	117062.0 Ops/sec
Find	226391.4 Ops/sec
FindIndex	301160.7 Ops/sec
Some	238569.6 Ops/sec

Related benchmarks:

Includes vs. IndexOf vs. Filter vs. Find vs. FindIndex vs. Some (version: 0)

Comparing performance of: Includes vs IndexOf vs Filter vs Find vs FindIndex vs Some

Created: 4 years ago by: Guest

Jump to the latest result

Includes

IndexOf

Filter

Find

FindIndex

Some

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 18 days ago):