Benchmark: indexOf vs findIndex vs for vs while vs indexed - 500 items

Script Preparation code:

var exampleItem1 = 'You will never find me!';
var exampleItem2 = 'I am invisible!';
var exampleArray = Array(500).fill('').map((x, i) => x + (i + 1));
var compare1 = x => x === exampleItem1;
var compare2 = x => x === exampleItem2;

Tests:

findIndex
exampleArray.findIndex(compare1); exampleArray.findIndex(compare2);
indexOf
exampleArray.indexOf(exampleItem1); exampleArray.indexOf(exampleItem2);
for
let index1 = null; let index2 = null; for (let i = 0, l = exampleArray.length; i < l; i += 1) { if (index1 === null && compare1(exampleArray[i])) { index1 = i; continue; } if (index2 === null && compare2(exampleArray[i])) { index2 = i; continue; } if (index1 !== null && index2 !== null) break; }
while
let index1 = null; let index2 = null; let i = -1, l = exampleArray.length; while (++i < l) { if (index1 === null && compare1(exampleArray[i])) { index1 = i; continue; } if (index2 === null && compare2(exampleArray[i])) { index2 = i; continue; } if (index1 !== null && index2 !== null) break; }
indexed
const indexes = {}; for (let i = 0, l = exampleArray.length; i < l; i += 1) { indexes[exampleArray[i]] = i; } let index1 = indexes[exampleItem1]; let index2 = indexes[exampleItem2];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
findIndex
indexOf
for
while
indexed

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 and explain what is being tested, compared, and their pros and cons.

**What is being tested?**

The benchmark measures the performance of four different approaches to find an item in an array:

1. `indexOf`: A built-in JavaScript method that finds the index of a specified value in an array.
2. `findIndex`: A built-in JavaScript method that returns the index of the first element in an array that satisfies a provided testing function.
3. For loop: An iterative approach using a traditional for loop to find the index of an item in an array.
4. While loop: An iterative approach using a while loop to find the index of an item in an array.
5. Indexed lookup: A specialized approach that uses an object to store indices of each element in the array.

**Options compared**

The benchmark compares the performance of the above five approaches with a large dataset (500 items) and two specific values (`exampleItem1` and `exampleItem2`) to find their indices in the array.

**Pros and Cons of each approach:**

1. **indexOf**:
	* Pros: Efficient, widely supported, and optimized by browsers.
	* Cons: May not be as fast for very large arrays or unique values, as it uses a linear search algorithm.
2. **findIndex**:
	* Pros: More efficient than `indexOf` for very large arrays with many duplicate values, as it stops searching once the first match is found.
	* Cons: Requires JavaScript version 5+ and may not be supported by older browsers or platforms.
3. **For loop**:
	* Pros: Simple and easy to understand, works well for small to medium-sized arrays.
	* Cons: Can be slow for large datasets due to the overhead of function calls and array iterations.
4. **While loop**:
	* Pros: Similar to the for loop but more flexible, allowing for easier iteration over custom conditions.
	* Cons: May require more code complexity and may not be as efficient as other approaches.
5. **Indexed lookup**:
	* Pros: Fastest approach due to the use of an object to store indices, which allows for O(1) lookups.
	* Cons: Requires additional memory and processing power to create and maintain the index object.

**Library/Utility**

There is no specific library or utility being used in this benchmark. However, the `Array.prototype.findIndex` method is a part of the JavaScript standard library and provides an efficient way to find the index of an item in an array.

**Special JS feature or syntax**

This benchmark does not use any special JavaScript features or syntax that are not commonly supported by modern browsers. It only relies on built-in methods, loops, and object-oriented programming concepts.

**Alternatives**

If you need a benchmarking tool for JavaScript performance testing, there are several alternatives to MeasureThat.net:

1. **BenchmarkDotNet**: A popular open-source benchmarking library for .NET, with support for JavaScript.
2. **JSCoverage**: A tool that provides detailed performance analysis of JavaScript code.
3. **jsPerf**: A simple online benchmarking tool specifically designed for testing JavaScript performance.

These alternatives offer varying degrees of features and customization options compared to MeasureThat.net, but can provide similar or more comprehensive insights into your JavaScript performance.

Related benchmarks:

indexOf vs findIndex vs for vs while vs indexed - 500 items (version: 0)

Comparing performance of: findIndex vs indexOf vs for vs while vs indexed

Created: 5 years ago by: Registered User

Jump to the latest result

findIndex

indexOf

for

while

indexed

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):