Benchmark: Some vs. Filter vs. indexOf vs. Includes vs. Find with fix

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(v => v === 0) : withoutZero.includes(v => v === 0);
Array.find
var tempResult = !!Math.round(Math.random()) ? hasZero.find(v => v === 0) : withoutZero.find(v => v === 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
Array.find

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Overview**

The provided JSON represents a benchmark with five test cases, each measuring the performance of different methods for searching arrays in JavaScript: `some`, `filter`, `indexOf`, `includes`, and `find`. The benchmark uses two arrays, `hasZero` and `withoutZero`, containing 10,000 random integers.

**Options Compared**

The following options are compared:

1. **Array.some**: This method returns `true` if at least one element in the array satisfies the provided callback function.
2. **Array.filter**: This method creates a new array with all elements that pass the test implemented by the provided callback function.
3. **Array.indexOf**: This method returns the index of the first occurrence of the specified value, or -1 if it is not found.
4. **Array.includes**: This method returns `true` if an element with the specified value exists in the array, and `false` otherwise.
5. **Array.find**: This method returns the first element that satisfies the provided callback function.

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

1. **Array.some**:
	* Pros: Simple, efficient, and suitable for most use cases.
	* Cons: Returns `true` as soon as it finds one match, which can lead to false positives if not all elements need to be checked.
2. **Array.filter**:
	* Pros: Creates a new array with filtered elements, preserving the original order.
	* Cons: More memory-intensive and computationally expensive than other methods.
3. **Array.indexOf**:
	* Pros: Fast and efficient for finding specific values in an array.
	* Cons: Returns -1 if the value is not found, which can be considered falsey in some contexts.
4. **Array.includes**:
	* Pros: Simple, readable, and suitable for most use cases.
	* Cons: May be slower than other methods due to its implementation.
5. **Array.find**:
	* Pros: Returns the first matching element, making it useful for finding a single value in an array.
	* Cons: Can throw exceptions if no elements match the callback function.

**Library Usage**

None of the test cases use any external libraries or frameworks.

**Special JavaScript Features/Syntax**

The benchmark uses:

1. **Arrows functions** (`=>`): Used to define short, concise functions within the `some`, `filter`, and `find` methods.
2. **Template literals** (`\r\n...`) for multi-line string formatting in the script preparation code.

**Other Alternatives**

If you need more control over array searching or want to explore alternative implementations, consider the following alternatives:

1. **Array.prototype.every()**: Returns `true` if all elements pass the test implemented by the provided callback function.
2. **Array.prototype.map()`: Creates a new array with the results of applying the provided callback function to each element in the original array.
3. **Custom loop-based implementations**: You can write your own loops to search arrays, but these are generally less efficient and more verbose than built-in methods.

Keep in mind that MeasureThat.net's benchmark is designed to compare the performance of different approaches across various browsers and devices, so it's essential to consider the specific requirements and constraints of your use case.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 119 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.some	261439.8 Ops/sec
Array.filter	51277.4 Ops/sec
Array.indexOf	1422988.4 Ops/sec
Array.includes	6279471.0 Ops/sec
Array.find	241564.3 Ops/sec

Related benchmarks:

Some vs. Filter vs. indexOf vs. Includes vs. Find with fix (version: 0)

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

Created: one year ago by: Guest

Jump to the latest result

Array.some

Array.filter

Array.indexOf

Array.includes

Array.find

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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