Benchmark: For loop vs Index Of (1000000 case)

Script Preparation code:

var arr = [];
var count = 1000000;
for(var i = 0; i<count; i++)
{
  arr.push(i);
}

Tests:

for loop
function indexOfFor(obj, list) { var i; for (i = 0; i < list.length; i++) { if (list[i] === obj) { return i; } } return -1; }; indexOfFor(900000, arr);
indexOf
arr.indexOf(900000, arr);

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

for loop

893/s

indexOf

15/s

Fastest: for loop (60.6x faster)

View exact numbers

✓ for loop: 893 ops/sec
• indexOf: 15 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for loop
indexOf

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0

Browser/OS: Firefox 121 on Windows

View result in a separate tab

for loop

1K/s

indexOf

61/s

View exact numbers

Test name	Executions per second
✓ for loop	1,027 Ops/sec
indexOf	61 Ops/sec

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 is being tested.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmark that compares two approaches: using a for loop and using the `indexOf` method of an array.

* **Script Preparation Code**: The script creates an empty array (`var arr = []`) and initializes a variable `count` with 1,000,000. It then uses a for loop to push each number from 0 to `count-1` onto the array.
* **Html Preparation Code**: This field is empty, which means no HTML preparation code is required for this benchmark.

**Individual Test Cases**

There are two test cases:

1. **For Loop**
	* The benchmark definition uses a custom function called `indexOfFor`, which implements a for loop to find the index of an element in the array.
	* The function iterates through the array using a for loop, checking each element's value against the target value (`obj`).
2. **IndexOf**
	* This test case uses the built-in `indexOf` method of JavaScript arrays to find the index of an element in the same array.

**Library/External Functions**

None are used explicitly in these benchmark definitions. However, it's worth noting that the `arr` variable is created using the `[]` syntax, which is a shorthand for creating an empty array.

**JavaScript Features/Syntax**

The benchmark uses JavaScript features like:

* For loops (`for (i = 0; i < list.length; i++)`)
* Array methods (`push`, `indexOf`)
* Custom function definition (`function indexOfFor(obj, list) { ... }`)

Now, let's discuss the pros and cons of each approach:

**For Loop**

Pros:

* More control over the iteration process
* Can be optimized for performance

Cons:

* May require more code than using built-in methods
* Can be less concise and harder to read

**IndexOf**

Pros:

* Built-in method, so it's likely to be implemented efficiently in the browser engine
* Concise and easy to read
* Often faster than a custom implementation due to optimizations by the browser engine

Cons:

* Less control over the iteration process
* May not work as expected if the array is not ordered or if the element is not found

**Other Alternatives**

If you wanted to write a more traditional loop-based solution without using `indexOf`, you could use a while loop instead of a for loop:
```javascript
function indexOfForLoop(obj, list) {
  var i = 0;
  while (i < list.length) {
    if (list[i] === obj) {
      return i;
    }
    i++;
  }
  return -1;
}
```
Another alternative would be to use the `findIndex` method on the array, which is similar to `indexOf` but returns the index of the first element that matches the predicate:
```javascript
function indexOfFindIndex(obj, list) {
  return list.findIndex((element) => element === obj);
}
```
Keep in mind that these alternatives may not be as efficient or concise as using the built-in `indexOf` method.

For loop vs Index Of (1000000 case) (version: 0)

save length of the array in the variable vs get it the loop

Comparing performance of: `for loop vs indexOf`

Created: 2 years ago by: Guest

Go to the latest result

for loop

indexOf

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

For loop vs Index Of (1000000 case) (version: 0)

save length of the array in the variable vs get it the loop

Comparing performance of: for loop vs indexOf

Created: 2 years ago by: Guest

Go to the latest result

for loop

indexOf

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `for loop vs indexOf`