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

Script Preparation code:

var tempResult = false;
var arr = [];
for (var i = 0; i < 10000; i++) {
  arr.push(Math.random());
}

Tests:

Array.some
var tempResult = !!arr.some(v => v === Math.random());
Array.filter
var tempResult = !!arr.filter(v => v === Math.random());
Array.indexOf
var tempResult = !!arr.indexOf(Math.random()) !== -1 ;
Array.includes
var tempResult = !!arr.includes(Math.random());
Array.find
var tempResult = !!arr.find(v => v === Math.random());

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 gemma2:9b, generated 27 days ago):

LLMs can make mistakes. Check important info.

This benchmark compares the performance of five different methods for finding a specific value within an array in JavaScript:

* **`Array.some()`:** Checks if *at least one* element in the array satisfies a given condition. 
* **`Array.filter()`:** Creates a *new* array containing only elements that satisfy a given condition.
* **`Array.indexOf()`:** Returns the index of the first occurrence of a given value, or -1 if not found.
* **`Array.includes()`:** Returns true if the array contains a given value, otherwise false.
* **`Array.find()`:**  Returns the *first* element in an array that satisfies a given condition.

**Pros and Cons:**

| Method        | Pros                                           | Cons                                         |
|---------------|-------------------------------------------------|----------------------------------------------|
| `some()`      | Simple to use, returns true if *any* match found | Doesn't return the matched value             |
| `filter()`    | Returns a new array with filtered elements     | Can be less performant than other methods for single value searches |
| `indexOf()`   | Efficient for finding the index of a single value | Only returns the index of the *first* occurrence |
| `includes()`  | Simple, returns true/false if value is present   | Doesn't return the matched value             |
| `find()`      | Returns the *first* matching element           | Can be less performant than other methods for single value searches |

**Considerations:**

* **Use case:** If you need to find a specific value and its index, `indexOf()` is usually the best choice. 
* **Return value:**  If you need to see all elements that match a condition, use `filter()`.
* **Performance:**  For single-value searches, `indexOf()` and `includes()` are generally the fastest methods.

**Other Alternatives:**

* **Manual Iteration:** Looping through the array yourself can be less efficient but offers more control.

Let me know if you'd like a deeper dive into any specific aspect of this benchmark!

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.80 Safari/537.36

Browser/OS: Chrome 98 on Linux

View result in a separate tab

Test name	Executions per second
Array.some	1014.0 Ops/sec
Array.filter	1035.1 Ops/sec
Array.indexOf	196306.2 Ops/sec
Array.includes	196108.0 Ops/sec
Array.find	1042.2 Ops/sec

Related benchmarks:

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

Correct version of the https://www.measurethat.net/Benchmarks/Show/9045/0/some-vs-filter-vs-indexof-vs-includes-vs-find benchmark

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

Created: 2 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 gemma2:9b, generated 27 days ago):