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

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

Autogenerated LLM Summary (model llama3.1:latest, generated 2 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript benchmarking.

**What is being tested?**

The provided JSON represents a benchmark test that compares the performance of five different methods for finding an element in an array:

1. `Array.some`
2. `Array.filter`
3. `Array.indexOf`
4. `Array.includes`
5. `Array.find`

**Options compared:**

Each method is being tested with the same input: an array of 10,000 random numbers and a target value (also a random number) to search for.

**Pros and cons of each approach:**

1. **`Array.some`**: This method returns `true` as soon as it finds a matching element in the array. It's useful when you need to find at least one occurrence of an element.
	* Pros: fast, returns immediately once found
	* Cons: might return incorrect results if the input array is modified while iterating over it (not relevant in this case)
2. **`Array.filter`**: This method creates a new array with all elements that pass a test implemented by a provided function. We're using it to find an element by checking its value.
	* Pros: can be used for more complex filtering logic
	* Cons: slower than `some` since it creates a new array, and might use more memory if the filtered array is large
3. **`Array.indexOf`**: This method returns the index of the first occurrence of an element in the array, or `-1` if not found.
	* Pros: fast, returns exact position of the element (if found)
	* Cons: assumes the input value can be used as a key for lookup (which is the case here), but might not work with complex data structures
4. **`Array.includes`**: This method returns `true` if an array includes at least one occurrence of an element.
	* Pros: fast, returns immediately once found
	* Cons: same as `some`, might return incorrect results if the input array is modified while iterating over it (not relevant in this case)
5. **`Array.find`**: This method returns the first element that satisfies a test implemented by a provided function.
	* Pros: fast, returns immediately once found
	* Cons: same as `some`, might return incorrect results if the input array is modified while iterating over it (not relevant in this case)

**Library usage:**

No external libraries are used in these benchmarks.

**JS feature or syntax:**

The following features and syntax are used:

1. Arrow functions (`v => v === Math.random()`)
2. Method chaining (`some`, `filter`, etc.)
3. Object shorthand notation (e.g., `"Name": "Some vs. Filter vs. indexOf vs. Includes vs. Find - fixed"`)

**Other considerations:**

The benchmark is executed on a Chrome 98 browser, running on Linux desktop. The results are measured in executions per second.

**Alternatives:**

In addition to the methods compared here, other alternatives for finding an element in an array include:

1. Using a `Set` to store unique values and then checking membership using the `has()` method.
2. Implementing a custom binary search algorithm.
3. Utilizing a data structure like a hash table or trie.

Keep in mind that these alternatives might have different trade-offs (e.g., speed, memory usage, complexity) depending on the specific use case.

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 llama3.1:latest, generated 2 months ago):