Benchmark: find vs includs - MeasureThat.net

Script Preparation code:

var arr = [];
var i = 0;

while (i <= 1E5) arr[i] = i++;

Tests:

Array.prototype.find
const item = arr.find(item => item == 1E5);
Array.prototype.findIndex
const index = arr.includes(1E5);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.find
Array.prototype.findIndex

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15

Browser/OS: Safari 14 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.prototype.find	9729.1 Ops/sec
Array.prototype.findIndex	12768.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the benchmark.

**Benchmark Purpose**
The goal of this benchmark is to compare the performance of two methods in the `Array` prototype: `find()` and `includes()`. The methods are being tested on an array generated by the script preparation code, which creates a large array with numbers from 0 to 100,000.

**Methods Being Compared**

1. **Array.prototype.find()**: This method returns the value of the first element in the array that satisfies the provided testing function.
2. **Array.prototype.includes()**: This method checks if a specified element is present in the array.

**Approaches and Pros/Cons**

Both methods are generally fast, but they have some differences:

*   `find()` method has to iterate through the array until it finds the first matching element, which can lead to slower performance for larger arrays.
*   `includes()` method returns a boolean result immediately if the specified value is found in the array, making it potentially faster.

**Pros and Cons**

*   **Find()**: Pros - Can be useful when you want to get the actual matching element rather than just checking its presence. Cons - Slower performance for larger arrays due to the need to iterate through elements.
*   **Includes():** Pros - Faster performance for large arrays as it returns a boolean result immediately.  Cons - Returns a boolean value instead of the actual matching element.

**Library Usage**
Neither `find()` nor `includes()` methods use any external libraries.

**Special JavaScript Features/Syntax**

There is no special JavaScript feature or syntax being tested in this benchmark.

**Other Alternatives**

If you're looking for alternative methods, here are some:

*   For finding the first occurrence of an element: You can also use a `for...of` loop with `break` statement to exit the loop once the condition is met.
*   For checking if an element is present in an array without using the `includes()` method: You can create your own implementation or use a library like Lodash.

Example of alternative implementation for finding the first occurrence:

```javascript
function findFirst(arr, value) {
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] === value) return arr[i];
    }
    return undefined;
}
```

Keep in mind that while this approach is straightforward, it may not be as efficient as the `find()` method.

Related benchmarks:

find vs includs (version: 0)

Measuring which is faster

Comparing performance of: Array.prototype.find vs Array.prototype.findIndex

Created: 4 years ago by: Guest

Jump to the latest result

Array.prototype.find

Array.prototype.findIndex

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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