Benchmark: for vs foreach vs for-const vs for..of

Script Preparation code:

var array = new Array(1000);

Tests:

for
let res=0 for (var i = 0; i < array.length; i++) { res += array[i] }
foreach
let res=0 array.forEach(function(i) { res += i });
for..of
let res=0 for (var i of array) { res += i }
for-const
let res=0 const leng = array.length for (var i = 0; i < leng; i++) { res += array[i] }

Historical Performance Data aggregated from 19 community runs

Desktop Results:

Chrome 13 runs

for..of

1.2M/s

foreach

1.2M/s

for-const

468K/s

for

468K/s

Fastest: for..of (2.6x faster)

View exact numbers

✓ for..of: 1,210,136 ops/sec
• foreach: 1,168,948 ops/sec
• for-const: 468,480 ops/sec
• for: 468,397 ops/sec

Firefox 6 runs

foreach

796K/s

for-const

715K/s

for

674K/s

for..of

214K/s

Fastest: foreach (3.7x faster)

View exact numbers

✓ foreach: 795,596 ops/sec
• for-const: 715,255 ops/sec
• for: 674,255 ops/sec
• for..of: 214,197 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
foreach
for..of
for-const

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 146 on Windows

View result in a separate tab

for..of

2.4M/s

foreach

2.0M/s

for-const

480K/s

for

468K/s

View exact numbers

Test name	Executions per second
✓ for..of	2,434,760 Ops/sec
foreach	1,973,587 Ops/sec
for-const	479,932 Ops/sec
for	468,397 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark compares the performance of four different loop constructs in JavaScript: traditional `for` loops, `forEach` loops, `for...of` loops, and `for...const` loops.

**Loop Constructs Compared**

1. **Traditional `for` loops**: These loops use a manual incrementing variable (`i`) to iterate over an array.
2. **`forEach` loops**: These loops use the built-in `Array.prototype.forEach()` method to iterate over an array, passing a callback function that will be executed for each element.
3. **`for...of` loops**: These loops use a syntax introduced in ECMAScript 2015 (ES6) to iterate over arrays and other iterable objects without requiring manual variable management.
4. **`for...const` loops**: These loops are similar to traditional `for` loops but use the `const` keyword to declare the loop variable, making it immutable.

**Options Compared**

The benchmark compares the performance of these four loop constructs:

* Raw execution time (measured in executions per second)
* Browser and device platform-specific results

**Pros and Cons of Each Approach**

1. **Traditional `for` loops**: Pros: more control over iteration variables; cons: verbose, error-prone.
2. **`forEach` loops**: Pros: concise syntax; cons: less control over iteration variables, can be slower due to callback function overhead.
3. **`for...of` loops**: Pros: concise and readable syntax; cons: limited flexibility (e.g., no support for manual iteration).
4. **`for...const` loops**: Pros: similar benefits to traditional `for` loops with the added benefit of immutability; cons: slightly less control over iteration variables.

**Library Used**

None explicitly mentioned in the provided JSON, but it is likely that the benchmark uses a standard JavaScript environment (e.g., Node.js or a browser).

**Special JS Features/Syntax**

* **`for...of` loops**: Introduced in ECMAScript 2015 (ES6), providing a concise and readable syntax for iterating over arrays and other iterable objects.
* **`for...const` loops**: Introduced in ECMAScript 2017, providing the benefits of traditional `for` loops with the added benefit of immutability.

**Alternatives**

If you're interested in exploring alternative loop constructs, consider:

1. **Closures**: Using a closure to encapsulate iteration logic can provide more control and flexibility than traditional loops.
2. **Generators**: Introducing generators as an alternative to traditional loops for iterating over arrays or other iterable objects.

Keep in mind that the performance benefits of these alternatives may vary depending on your specific use case.

**Conclusion**

The benchmark provides a useful comparison of four different loop constructs, highlighting their strengths and weaknesses. By choosing the right loop construct for your use case, you can improve code readability, maintainability, and performance.

for vs foreach vs for-const vs for..of (version: 0)

Compare loop performance

Comparing performance of: `for vs foreach vs for..of vs for-const`

Created: one year ago by: Guest

Go to the latest result

for

foreach

for..of

for-const

Historical Performance Data aggregated from 19 community runs

Desktop Results:

Chrome 13 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

for vs foreach vs for-const vs for..of (version: 0)

Compare loop performance

Comparing performance of: for vs foreach vs for..of vs for-const

Created: one year ago by: Guest

Go to the latest result

for

foreach

for..of

for-const

Historical Performance Data aggregated from 19 community runs

Desktop Results:

Chrome 13 runs

Firefox 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `for vs foreach vs for..of vs for-const`