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: one month ago)

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

Browser/OS: Firefox 149 on Windows

View result in a separate tab

Optimised while loop

667K/s

Optimised classic for loop

627K/s

While loop

620K/s

Classic for loop

590K/s

Array.prototype.forEach

182K/s

Array.prototype.reduce

168K/s

For - of loop

133K/s

For - in loop

15K/s

View exact numbers

Test name	Executions per second
✓ Optimised while loop	667,296 Ops/sec
Optimised classic for loop	626,806 Ops/sec
While loop	619,855 Ops/sec
Classic for loop	589,707 Ops/sec
Array.prototype.forEach	182,040 Ops/sec
Array.prototype.reduce	168,281 Ops/sec
For - of loop	133,108 Ops/sec
For - in loop	14,933 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 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.

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: 2 years ago by: Guest

Go 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>

Fastest: N/A

Slowest: N/A

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

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: 2 years ago by: Guest

Go 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>

Fastest: N/A

Slowest: N/A

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

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`