Benchmark: For Loop vs While Loop vs indexOf

Script Preparation code:

var arr = ['apple', 'banana', 'cherry', 'donuts', 'eggplant', 'french fries', 'goulash', 'hamburger', 'ice cream', 'juice', 'kebab', 'lemonade', 'mango', 'nuts', 'octopus', 'parsley', 'quail egg', 'risotto', 'stew', 'tapas', 'udon', 'vanilla', 'wheat', 'xylotil', 'yogurt', 'zucchinni'];

function forLoop(array, item) {
	for (var i = 0; i < array.length; i++) {
    	if (array[i] === item) {
          return i;
        }
    }
    return -1;
}

function whileLoop(array, item) {
  	var i = 0;
	while (i < array.length) {
    	if (array[i] === item) {
        	return i;
        }
      	i += 1;
    }
    return -1;
}

function indexOfNative(array, item) {
	return array.indexOf(item);
}

Tests:

For Loop for item towards beginning
forLoop(arr, 'donuts')
While Loop for item towards beginning
whileLoop(arr, 'donuts')
indexOf for item towards beginning
indexOfNative(arr, 'donuts')
For Loop for item towards end
forLoop(arr, 'yogurt')
While Loop for item towards end
whileLoop(arr, 'yogurt')
indexOf for item towards end
indexOfNative(arr, 'yogurt')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For Loop for item towards beginning
While Loop for item towards beginning
indexOf for item towards beginning
For Loop for item towards end
While Loop for item towards end
indexOf for item towards end

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
For Loop for item towards beginning	3604845.2 Ops/sec
While Loop for item towards beginning	3610887.2 Ops/sec
indexOf for item towards beginning	3636966.8 Ops/sec
For Loop for item towards end	3400987.2 Ops/sec
While Loop for item towards end	2936124.5 Ops/sec
indexOf for item towards end	2765751.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and explain what's being tested.

**Benchmark Definition**

The benchmark defines three functions:

1. `forLoop(array, item)`: A traditional `for` loop that iterates through an array and returns the index of the first occurrence of a specified item.
2. `whileLoop(array, item)`: A `while` loop that iterates through an array and returns the index of the first occurrence of a specified item.
3. `indexOfNative(array, item)`: A native JavaScript function `Array.indexOf()` that returns the index of the first occurrence of a specified item in the given array.

**Options Compared**

The benchmark compares the performance of these three functions under two different scenarios:

* **Item towards beginning**: The test case searches for an item near the start of the array.
* **Item towards end**: The test case searches for an item near the end of the array.

**Pros and Cons**

Here's a brief analysis of each approach:

1. `forLoop(array, item)`:
	* Pros: Simple, easy to understand, and might be faster for small arrays.
	* Cons: Can be slower for large arrays due to the overhead of incrementing the loop counter.
2. `whileLoop(array, item)`:
	* Pros: Might be faster for large arrays since it only increments the index variable when necessary.
	* Cons: More complex than a simple `for` loop and might have additional overhead due to the loop condition.
3. `indexOfNative(array, item)`:
	* Pros: Native implementation with built-in performance optimization.
	* Cons: May not be available in older browsers or environments.

**Library**

The benchmark uses no external libraries besides the standard JavaScript arrays. However, it's worth noting that modern browsers have optimized implementations of `Array.indexOf()` under the hood, which might affect the results.

**Special JS Feature/Syntax**

None mentioned, as this benchmark focuses on a straightforward implementation of loops and indexing.

**Alternatives**

If you're interested in exploring alternative approaches or optimizing these functions further:

* Consider using more advanced data structures like binary search trees (BSTs) or hash tables for faster lookup times.
* Explore using specialized libraries or frameworks that provide optimized implementations for array operations, such as NumJS or Arrayify.
* Investigate using parallel processing techniques to take advantage of multi-core processors.

Keep in mind that the choice of implementation and optimization strategies depends on the specific use case and performance requirements.

Related benchmarks:

For Loop vs While Loop vs indexOf (version: 0)

Comparing performance of: For Loop for item towards beginning vs While Loop for item towards beginning vs indexOf for item towards beginning vs For Loop for item towards end vs While Loop for item towards end vs indexOf for item towards end

Created: 4 years ago by: Guest

Jump to the latest result

For Loop for item towards beginning

While Loop for item towards beginning

indexOf for item towards beginning

For Loop for item towards end

While Loop for item towards end

indexOf for item towards end

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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