Benchmark: while vs for vs forEach vs for of - 1000000 - calc exponent multiple

Script Preparation code:

var arr =new Array(1000000);

Tests:

while
let i=0; while(i < arr.length) { const exp = arr[i] ** 2 ** 2 ** 2 ** 2; i++; }
for
for(let i=0; i<arr.length; i++) { const exp = arr[i] ** 2 ** 2 ** 2 ** 2; }
forEach
arr.forEach((element) => { const exp = element ** 2 ** 2 ** 2 ** 2; });
for of
for(const element of arr) { const exp = element ** 2 ** 2 ** 2 ** 2; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
while
for
forEach
for of

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.

The provided benchmark measures the performance of four different ways to iterate over an array in JavaScript: `while`, `for`, `forEach`, and `for...of`. The test case calculates the square of each element in the array 4 times.

Let's break down each option:

1. **While**: This method uses a traditional loop with a conditional statement to increment the index variable. In this case, the loop increments `i` after calculating the exponent.
	* Pros: Simple and easy to understand. Works for arrays of any size.
	* Cons: Can be slower due to the extra increment operation.
2. **For**: This method uses a traditional loop with an iterator variable that increments automatically. In this case, `i` is incremented implicitly at the end of each iteration.
	* Pros: Efficient and fast. Reduces the number of increment operations compared to `while`.
	* Cons: May not be as intuitive for developers who are not familiar with the syntax.
3. **ForEach**: This method uses a callback function that is called for each element in the array. In this case, the callback calculates the exponent and returns.
	* Pros: Concise and readable. No need to worry about indexing or incrementing manually.
	* Cons: May be slower due to the overhead of the callback function and the need to access the `element` variable.
4. **For...of**: This method uses a newer syntax that allows iterating over arrays without an explicit index variable. In this case, `element` is used directly in the loop body.
	* Pros: Modern and concise. Reduces clutter compared to traditional `for` loops.
	* Cons: May not be supported by older browsers or versions of JavaScript.

The test case uses a library called `array-polyfill`, which provides polyfills for older browsers that may not support modern JavaScript features. The library is used to ensure compatibility across different environments.

In this benchmark, the performance results show that:

* `for...of` is the fastest option, followed closely by `for`.
* `forEach` is slower than both of these options.
* `while` is the slowest option.

These results may vary depending on the specific use case and environment. It's essential to note that the best approach depends on the specific requirements of your project and the performance characteristics you need to achieve.

Other alternatives for iterating over arrays in JavaScript include:

* Using a traditional `for` loop with an index variable.
* Using a library like Lodash or Ramda, which provide optimized iteration functions.
* Using modern JavaScript features like `map()`, `filter()`, and `reduce()` for array operations.

Related benchmarks:

while vs for vs forEach vs for of - 1000000 - calc exponent multiple (version: 0)

Compare the new ES6 spread operator with the traditional concat() method and push

Comparing performance of: while vs for vs forEach vs for of

Created: 4 years ago by: Guest

Jump to the latest result

while

for

forEach

for of

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