Benchmark: for vs for with cached length vs foreach vs for..of

Script Preparation code:

var array = new Array(100);
var alen = array.length;

Tests:

for
for (var i = 0; i < array.length; i++) { array[i]; }
foreach
array.forEach(function(i) { array[i]; });
for..of
for (var i of array) { array[i]; }
for with cached length
for (var i = 0, len = array.length; i < len; i++) { array[i]; }
for with pre-cached length
for (var i = 0; i < alen; i++) { array[i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
foreach
for..of
for with cached length
for with pre-cached length

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 99 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
for	137734.2 Ops/sec
foreach	3856055.0 Ops/sec
for..of	237223.7 Ops/sec
for with cached length	275653.2 Ops/sec
for with pre-cached length	138767.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Definition**

The provided JSON represents a benchmark test that compares the performance of different loop constructs in JavaScript: `for`, `foreach`, and variations thereof (`for with cached length` and `for..of`). The goal is to determine which approach yields the fastest execution time.

**Loop Constructs Compared**

1. **Classic `for` loop**: This is the most basic type of loop, where you increment a counter variable (`i`) manually.
2. **`foreach` loop**: This loop iterates over an array using a callback function that receives the current element as an argument.
3. **`for..of` loop**: Introduced in ECMAScript 2015 (ES6), this loop is designed to iterate over arrays and other iterable objects, providing a more concise syntax than traditional `for` loops.
4. **`for with cached length`**: In this variation, the array's length is stored in a separate variable (`alen`) and used to increment the counter (`i`). This approach avoids the overhead of repeatedly accessing `array.length`.
5. **`for with pre-cached length`**: Similar to the previous point, but the loop increments `i` using the cached value of `alen`.

**Pros and Cons**

*   **Classic `for` loop**: Lightweight, easy to understand, and supports various iterations (e.g., `while`, `do-while`). However, manual counter management can lead to errors.
*   **`foreach` loop**: Provides a concise syntax for iterating over arrays. It's often more readable than traditional `for` loops but may have performance overhead due to callback function creation.
*   **`for..of` loop**: Offers a modern, expressive syntax that eliminates the need to manually increment a counter. However, it might not be supported in older browsers or Node.js versions.

**Library and Special Features**

None mentioned in this specific benchmark definition.

**Special JS Features or Syntax**

The `for..of` loop was introduced as a new iteration mechanism in ES6 (2015), providing an elegant way to iterate over arrays without manually incrementing counters. This syntax is more modern, readable, and efficient than traditional `for` loops for many cases.

**Alternatives**

Other alternatives to these loop constructs include:

*   **While loops**: Use the `while` keyword to create a loop that continues as long as a condition is true.
*   **Do-while loops**: Similar to while loops but with an additional initialization statement before the loop body.

Related benchmarks:

for vs for with cached length vs foreach vs for..of (version: 0)

Compare loop performance

Comparing performance of: for vs foreach vs for..of vs for with cached length vs for with pre-cached length

Created: 2 years ago by: Guest

Jump to the latest result

for

foreach

for..of

for with cached length

for with pre-cached length

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