Benchmark: For Loop vs While Loop vs indexOf vs includes

For Loop vs While Loop vs indexOf vs includes (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 vs includes for item towards start vs includes for item towards end

Created: 4 years ago by: Registered User

Jump to the latest result

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);
}

function includesNative(array, item) {
    return array.includes(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')
includes for item towards start
includesNative(arr, 'donuts')
includes for item towards end
includesNative(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
includes for item towards start
includes for item towards end

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 11 months ago)

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

Browser/OS: Chrome 136 on Windows

View result in a separate tab

Test name	Executions per second
For Loop for item towards beginning	80248000.0 Ops/sec
While Loop for item towards beginning	83058312.0 Ops/sec
indexOf for item towards beginning	79340216.0 Ops/sec
For Loop for item towards end	26582530.0 Ops/sec
While Loop for item towards end	22366056.0 Ops/sec
indexOf for item towards end	25265670.0 Ops/sec
includes for item towards start	62124040.0 Ops/sec
includes for item towards end	25703474.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and the pros and cons of each approach.

**Benchmark Overview**

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

1. For Loop
2. While Loop
3. indexOf (native JavaScript function)
4. includes (native JavaScript function)

Each test case uses a specific input array (`arr`) with multiple items, and a target item to search for. The benchmark is executed on Firefox 131 on a desktop platform.

**Approaches Compared**

1. **For Loop**: This approach iterates over the array using a traditional `for` loop, checking each element to see if it matches the target item.
2. **While Loop**: Similar to the For Loop, but uses a `while` loop instead.
3. **indexOf (native JavaScript function)**: This is a built-in JavaScript function that returns the index of the first occurrence of a specified value in an array.
4. **includes (native JavaScript function)**: Another native JavaScript function that returns true if the array includes the specified value, and false otherwise.

**Pros and Cons**

1. **For Loop**:
	* Pros: Simple, easy to understand, and can be optimized for performance using techniques like memoization.
	* Cons: Can be slow for large arrays due to the overhead of the loop and checks.
2. **While Loop**:
	* Pros: Similar to the For Loop, but with a slightly different syntax.
	* Cons: Same as the For Loop, in terms of performance characteristics.
3. **indexOf (native JavaScript function)**:
	* Pros: Fast and efficient, as it uses optimized native code.
	* Cons: May not be supported on all browsers or platforms.
4. **includes (native JavaScript function)**:
	* Pros: Similar to indexOf, but with the added benefit of returning a boolean value instead of an index.
	* Cons: Same as indexOf, in terms of performance characteristics.

**Library and Special Features**

None mentioned in this benchmark.

**Other Alternatives**

1. **Array.prototype.some()**: This method returns true if at least one element in the array matches the specified condition.
2. **Array.prototype.every()**: Similar to some(), but returns true if all elements match the condition.
3. **Linear search algorithms**: There are other search algorithms, like binary search, that can be used for large arrays, but they may not be applicable here.

In summary, this benchmark compares the performance of four different approaches to find an item in an array: For Loop, While Loop, indexOf (native JavaScript function), and includes (native JavaScript function). The results will help determine which approach is fastest and most efficient.

Related benchmarks: