Benchmark: JS loops and iterators

Script Preparation code:

var array = new Array(1000).fill(Math.random(1000) * 1000);

Tests:

Classic for loop
let sum = 0; for (let i=0; i < array.length; i++) { sum += array[i]; }
Optimised classic for loop
let sum = 0; for (let i=0, len=array.length; i < len; i++) { sum += array[i]; }
While loop
let sum = 0; let i = 0; while (i < array.length) { sum += array[i]; i++; }
Optimised while loop
let sum = 0; let i = 0; let len = array.length; while (i < len) { sum += array[i]; i++; }
Array.prototype.forEach
let sum = 0; array.forEach(num => sum += num);
Array.prototype.reduce
const sum = array.reduce((acc, el) => acc + el, 0);
For - of loop
let sum = 0; for (let el of array) { sum += el; }
For - in loop
let sum = 0; for (let i in array) { sum += array[i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Classic for loop
Optimised classic for loop
While loop
Optimised while loop
Array.prototype.forEach
Array.prototype.reduce
For - of loop
For - in loop

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Classic for loop	15152.5 Ops/sec
Optimised classic for loop	28270.7 Ops/sec
While loop	15154.4 Ops/sec
Optimised while loop	28216.8 Ops/sec
Array.prototype.forEach	271921.3 Ops/sec
Array.prototype.reduce	2686007.5 Ops/sec
For - of loop	733112.5 Ops/sec
For - in loop	22517.9 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark definition and test cases to explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark is focused on comparing the speed of different JavaScript loops for calculating the sum of an array.

**Test Cases**

There are six test cases:

1. **Classic for loop**: The traditional `for` loop with a variable declaration (`let i = 0;`) and increment.
2. **Optimized classic for loop**: A variation of the classic for loop with the length declaration (`len=array.length`) instead of accessing it inside the loop.
3. **While loop**: A `while` loop that iterates until the condition is false, used to calculate the sum of an array.
4. **Optimized while loop**: Similar to the optimized classic for loop, but uses a variable declaration (`let i = 0;`) instead of accessing it inside the loop.
5. **Array.prototype.forEach**: The `forEach` method on the Array prototype, which is used to iterate over an array and perform an action on each element.
6. **For-in loop**: A legacy `for...in` loop that iterates over the indices of an object (or array) using the `in` keyword.

**What's being tested**

The benchmark tests the execution speed of these different looping constructs when calculating the sum of a large array. The test aims to determine which method is the fastest and most efficient.

**Options compared**

* Classic for loop vs. Optimized classic for loop
* While loop vs. Optimized while loop
* Array.prototype.forEach vs. other methods
* For-in loop vs. other methods

**Pros and Cons of each approach:**

1. **Classic for loop**: Easy to understand, but not optimized for performance.
2. **Optimized classic for loop**: Reduces the overhead of accessing `array.length` inside the loop, improving performance.
3. **While loop**: Flexible and can be used in various situations, but may have additional complexity due to conditional logic.
4. **Optimized while loop**: Similar to optimized classic for loop, with the added benefit of variable declaration.
5. **Array.prototype.forEach**: Convenient and expressive method, but may incur performance overhead due to its nature.
6. **For-in loop**: Legacy syntax that can be confusing, especially when used with arrays.

**General observations:**

* Optimized loops (Optimized classic for loop and Optimized while loop) tend to outperform the traditional `for` loop due to reduced overhead.
* The Array.prototype.forEach method may incur additional performance overhead compared to optimized loops.
* The For-in loop is likely to be the slowest due to its legacy syntax and inherent limitations.

Keep in mind that these are general observations, and actual results may vary depending on specific use cases and environment conditions.

Related benchmarks:

JS loops and iterators (version: 0)

Comparing speed of JavaScript loops

Comparing performance of: Classic for loop vs Optimised classic for loop vs While loop vs Optimised while loop vs Array.prototype.forEach vs Array.prototype.reduce vs For - of loop vs For - in loop

Created: one year ago by: Guest

Jump to the latest result

Classic for loop

Optimised classic for loop

While loop

Optimised while loop

Array.prototype.forEach

Array.prototype.reduce

For - of loop

For - in loop

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