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

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

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.includes(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.filter(v => v === 0).length > 0 : withoutZero.filter(v => v === 0).length > 0;
Find
var tempResult = !!Math.round(Math.random()) ? typeof hasZero.find(v => v === 0) !== 'undefined' : typeof withoutZero.find(v => v === 0) !== 'undefined';
FindIndex
var tempResult = !!Math.round(Math.random()) ? hasZero.findIndex(v => v === 0) > -1 : withoutZero.findIndex(v => v === 0) > -1;
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

Latest run results:

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

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

Browser/OS: Chrome 88 on Windows

View result in a separate tab

Test name	Executions per second
Includes	1504205.4 Ops/sec
IndexOf	132484.6 Ops/sec
Filter	44259.7 Ops/sec
Find	183159.0 Ops/sec
FindIndex	120074.5 Ops/sec
Some	154751.3 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 provided benchmark definition and test cases.

**Benchmark Definition**

The website measures the performance of different methods for searching or filtering elements in an array:

* `includes()`
* `indexOf()`
* `filter()`
* `find()`
* `findIndex()`
* `some()`

Each method is compared to determine which one is the fastest.

**Options Compared**

Here's a brief description of each option and their pros and cons:

1. **`includes()`**: Returns `true` if an element with the specified value exists in the array.
	* Pros: Simple, readable code.
	* Cons: May be slower for large arrays due to the need to search every element.
2. **`indexOf()`**: Returns the index of the first occurrence of the specified value in the array.
	* Pros: Can return early if the value is not found, making it potentially faster than `includes()`.
	* Cons: May require additional checks for negative indices or edge cases.
3. **`filter()`**: Creates a new array with all elements that pass the provided test function.
	* Pros: Can be useful for more complex filtering logic, but may incur overhead due to creating a new array.
	* Cons: May not be as efficient as other methods for simple filtering tasks.
4. **`find()`**: Returns the value of the first element in the array that satisfies the provided test function.
	* Pros: Can return early if the value is not found, making it potentially faster than `includes()`.
	* Cons: May require additional checks for null or undefined values.
5. **`findIndex()`**: Returns the index of the first occurrence of the specified value in the array.
	* Pros: Faster and more efficient than `indexOf()`, especially for large arrays.
	* Cons: Returns -1 if the value is not found, which may require additional checks.
6. **`some()`**: Returns `true` if at least one element in the array satisfies the provided test function.
	* Pros: Can be useful for more complex filtering logic, but may incur overhead due to the need to check every element.
	* Cons: May not be as efficient as other methods for simple filtering tasks.

**Libraries and Special Features**

The benchmark uses Lodash.js library, which provides the `some()` function. Other libraries or features are not used in this benchmark.

**Special Feature - Nullish Coalescing Operator (`??`)**

The `!!Math.round(Math.random())` expression is used to introduce some randomness into the benchmark results. This is a special feature introduced in ECMAScript 2020, which allows for nullish coalescing between two values. In this case, it's used to create a random boolean value that will be used to determine whether to call one of the `includes()`, `indexOf()`, or other methods.

In summary, this benchmark tests the performance of different array searching and filtering methods in JavaScript, with a focus on simplicity, readability, and efficiency. The results can help developers choose the best approach for their specific use cases.

Related benchmarks:

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

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

Created: 3 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 Summary (model llama3.2:3b, generated 2 months ago):