Benchmark: for..of VS forEach

Script Preparation code:

var values = new Array(10000);
for (var i = 0; i < values.length; i++) values[i]=i;

Tests:

forEach
var sum = 0; values.forEach(v => sum += v );
for..of
var sum = 0; for (var v of values) sum += v;
forEach func
var sum = 0; values.forEach(function(v) { sum += v } );
for of transpiled
var sum = 0; for (var _i = 0, _a=values, _l=_a.length; _i < _l; _i++) sum += _a[i];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
for..of
forEach func
for of transpiled

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Definition**

The benchmark is designed to compare the performance of three ways to iterate over an array: `forEach`, `for..of`, and a variation of `for..of` with transpilation.

In summary, we're comparing:

1. The standard `forEach` method, which takes a callback function as its first argument.
2. The `for..of` loop, which is a newer way to iterate over arrays in JavaScript.
3. A variant of the `for..of` loop that has been transpiled (compiled) to older JavaScript syntax.

**Comparison Options**

The three options are compared in terms of their execution time, measured in executions per second.

* The fastest option will be reported as having the highest "ExecutionsPerSecond" value.
* The slower option(s) will have lower "ExecutionsPerSecond" values.

**Pros and Cons of Each Approach**

1. **Standard `forEach` method**:
	* Pros: Simple to implement, widely supported across browsers.
	* Cons: Can be slower than other approaches due to the overhead of calling a callback function on each iteration.
2. **`for..of` loop**:
	* Pros: Fast and efficient, allows for better control over iteration variables.
	* Cons: Requires modern JavaScript support (not compatible with older browsers).
3. **Transpiled `for..of` loop**:
	* Pros: Allows for compatibility with older JavaScript syntax, potentially reducing compatibility issues.
	* Cons: May introduce additional overhead due to the transpilation process.

**Library and Syntax Used**

The `forEach` method uses a built-in JavaScript function, while the `for..of` loops use a new iteration syntax introduced in ECMAScript 2015 (ES6).

There are no special JavaScript features or syntaxes used in this benchmark beyond what's already discussed.

**Other Alternatives**

If you're interested in exploring other ways to iterate over arrays, here are some alternatives:

1. **Array.prototype.reduce()**: This method can be used for array iteration and reduction, but it's not typically used for simple loop iterations.
2. **Array.prototype.map()**: Similar to `reduce()`, but designed specifically for transforming arrays without modifying the original data.

Keep in mind that these alternatives may have different performance characteristics or use cases compared to the methods tested in this benchmark.

Now that we've explored the world of JavaScript microbenchmarks, it's clear that the choice of iteration method can significantly impact performance. The `for..of` loop appears to be the fastest option, followed closely by the transpiled version. However, compatibility issues may arise when targeting older browsers, making the standard `forEach` method a viable alternative in those cases.

Latest run results:

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

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

Browser/OS: Chrome 58 on Mac OS X 10.12.3

View result in a separate tab

Test name	Executions per second
forEach	4262.0 Ops/sec
for..of	34568.6 Ops/sec
forEach func	3949.3 Ops/sec
for of transpiled	837.7 Ops/sec

Related benchmarks:

for..of VS forEach (version: 0)

Comparing performance of: forEach vs for..of vs forEach func vs for of transpiled

Created: 7 years ago by: Guest

Jump to the latest result

forEach

for..of

forEach func

for of transpiled

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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