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

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

Latest run results:

Run details: (Test run date: 15 hours ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Array.some	620852.4 Ops/sec
Array.filter	115169.0 Ops/sec
Array.indexOf	2748986.0 Ops/sec
Array.includes	2636011.2 Ops/sec
Array.find	628962.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested on MeasureThat.net.

The benchmark consists of five individual test cases, each measuring the performance of different methods for checking if an array contains a specific value. The methods being compared are:

1. `Array.some()`: This method returns `true` as soon as it finds at least one element in the array that satisfies the provided condition.
2. `Array.filter()`: This method creates a new array with all elements that pass the test implemented by the provided function.
3. `Array.indexOf()`: This method returns the index of the first element that matches the specified value, or -1 if it's not found.
4. `Array.includes()` (introduced in ECMAScript 2015): This method returns `true` if at least one element in the array is equal to the specified value, otherwise it returns `false`.
5. `Array.find()`: This method returns the first element that satisfies the provided condition, or `undefined` if no elements match.

Now, let's discuss the pros and cons of each approach:

**Array.some():**

Pros: Simple to implement, efficient for arrays with only one matching element.
Cons: May be slower than other methods for larger arrays due to its early return behavior.

**Array.filter():**

Pros: More expressive than `some()`, can be used to create new arrays, and is generally faster for larger arrays.
Cons: Creates a new array, which can be memory-intensive.

**Array.indexOf():**

Pros: Fast and efficient, returns the index of the first match, but may return -1 if not found.
Cons: Returns an integer value, which might not be immediately obvious as a boolean result.

**Array.includes():**

Pros: Introduced in ECMAScript 2015, designed for simplicity and readability, and is generally faster than `indexOf()` and `some()`.
Cons: May have performance overhead due to its implementation.

**Array.find():**

Pros: Simple to implement, efficient for arrays with only one matching element, returns the first match.
Cons: May return `undefined` if no elements match.

The test cases use a common setup: an array of 10,000 random integers (0-999), divided into two parts: `hasZero` and `withoutZero`. The benchmark measures how quickly each method can iterate through this array and find at least one element that matches the condition (`v === 0` for `some()` and `find()`, or `v === 1` for `filter()`).

The results show that `Array.includes()` is generally the fastest, followed closely by `Array.indexOf()`. `Array.some()` is slower due to its early return behavior. `Array.filter()` creates a new array, which slows it down. `Array.find()` is similar to `some()`, but may have slightly better performance.

As for special JS features or syntax, none are explicitly mentioned in the benchmark setup, but `includes()` and `find()` do demonstrate modern JavaScript features introduced after ECMAScript 2012.

Other alternatives to these methods might include:

* Using `Array.prototype.every()` for arrays with a single value
* Implementing custom iteration using a loop and conditional statements
* Utilizing native methods like `Set` or `Map` for faster lookups (although this requires additional setup)

In summary, the benchmark provides a straightforward comparison of different array iteration methods, highlighting their strengths and weaknesses.

Related benchmarks:

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

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

Created: 4 years 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 2 months ago):