Benchmark: executable indexOf vs findIndex

Script Preparation code:


var arr = ['one', 'two', 'three'];

function test(){
	return 'one';
}

Tests:

findIndex
arr.findIndex(el => el === test())
indexOf
arr.indexOf(test())

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
findIndex
indexOf

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases to understand what's being tested.

**Benchmark Definition:**
The benchmark is comparing two JavaScript methods: `findIndex` and `indexOf`. Both methods are used to find the index of a specific element in an array. However, there's a key difference between them:

*   `indexOf()` returns the index of the first occurrence of the specified value, or -1 if the value is not found.
*   `findIndex()` returns the index of the first element that satisfies the provided testing function (in this case, `el => el === test()`).

**Script Preparation Code:**
The script preparation code defines an array `arr` and a function `test()` that returns the string `'one'`. This is used as the target value in the `findIndex` and `indexOf` tests.

**Html Preparation Code:**
There's no HTML preparation code provided, which means the test cases are executed solely in the JavaScript environment.

Now, let's discuss the options compared in these benchmark tests:

*   **Find Index (Array.prototype.findIndex())**: This method is used to find the index of the first element that satisfies the testing function (`el => el === test()`). It returns -1 if no such element is found.
    *   Pros:
        *   More expressive and flexible than `indexOf`, as it allows for custom testing functions.
        *   Can be more efficient for large arrays since it stops searching as soon as a match is found.
    *   Cons:
        *   Older browsers might not support this method, although Chrome 92 does in this case.
*   **IndexOf (Array.prototype.indexOf())**: This method is used to find the index of the first occurrence of the specified value. If the value is not found, it returns -1.
    *   Pros:
        *   Widely supported across older browsers and JavaScript environments.
        *   Faster execution time since it's optimized for simple array searches.
    *   Cons:
        *   Less flexible than `findIndex`, as it requires a fixed string comparison.

In this benchmark, both methods are compared on the same array (`arr`), using the same test function (`test()`). The results show that:

*   `findIndex` executed approximately 23% more times per second (25.6 vs 20.6) than `indexOf`, indicating potentially better performance for large arrays.
*   However, `indexOf` still outperformed `findIndex` in this specific test case due to Chrome's optimized execution.

**Other Considerations:**

*   In some cases, using `findIndex()` might be overkill if you're only interested in the first occurrence of a value. In such scenarios, `indexOf()` might be a more suitable choice.
*   If your use case involves searching for a specific value in an array with many unique elements, `findIndex()` could be a better option.

**Alternative Approaches:**

*   For even more performance-critical code or when working with large arrays, consider using native WebAssembly (WASM) or low-level JavaScript methods like `BinarySearch()`.
*   When dealing with older browsers that don't support modern Array.prototype methods, you might need to use polyfills or alternative libraries.

In summary, this benchmark compares the performance of two popular array methods in JavaScript: `findIndex()` and `indexOf()`. While both methods have their pros and cons, the results suggest that for this particular test case, `indexOf()` outperformed `findIndex()` due to Chrome's optimized execution. However, when working with large arrays or requiring more flexibility in your search function, `findIndex()` might be a better choice.

Related benchmarks:

executable indexOf vs findIndex (version: 0)

Comparing performance of: findIndex vs indexOf

Created: 5 years ago by: Guest

Jump to the latest result

findIndex

indexOf

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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