Benchmark: for-vs-foreach-vs-forof

Script Preparation code:

var arr = [];
for (var i = 0; i < 1000; i++) {
  arr[i] = i;
}
function someFn(i) {
  return i * 3 * 8;
}

Tests:

forEach
arr.forEach(function (item){ someFn(item); });
for
for (var i = 0, len = arr.length; i < len; i++) { someFn(arr[i]); }
for of
for(xxx of arr){ someFn(xxx); }
arrowForEach
arr.forEach((item)=>{ someFn(item); });
forBackward
for (var i=arr.length-1; i>=0; i--) { someFn(arr[i]); }
reverse while
var i = arr.length; while (i--) { someFn(arr[i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
for
for of
arrowForEach
forBackward
reverse while

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its results.

**Benchmark Overview**

The `for-vs-foreach-vs-forof` benchmark compares the performance of three different loops:

1. `forEach`: Iterates over an array using the `Array.prototype.forEach()` method, which calls a callback function for each element in the array.
2. `for`: A traditional `for` loop that iterates over an array using its length property and index variable.
3. `for-of`: The newer `for...of` loop syntax, introduced in ECMAScript 2015 (ES6), which is used to iterate over iterable objects like arrays.

**Library Used**

None, this benchmark does not use any external libraries.

**Special JS Features/Syntax**

The `for-of` loop uses the new `for...of` syntax, which is a modern JavaScript feature introduced in ES6. This loop iterates over an array by simply using its elements as values in the iteration.

**Pros and Cons of Different Approaches**

1. **forEach**: This approach can be less efficient than traditional loops because it involves more overhead due to function calls.
	* Pros: Cleaner and more concise code, easier to write and read.
	* Cons: May incur additional function call overhead, potentially slower performance.
2. **for**: Traditional `for` loops are generally faster and more efficient because they don't involve the overhead of function calls.
	* Pros: Faster performance, lower memory usage.
	* Cons: More verbose code, harder to read and maintain.
3. **for-of**: The new `for...of` loop syntax is a compromise between `forEach` and traditional `for` loops.
	* Pros: Cleaner and more concise code than traditional `for` loops, similar performance to traditional loops.
	* Cons: Requires support for modern JavaScript versions (ES6+), may not be as well-known or widely supported.

**Other Considerations**

* The results of this benchmark are specific to the given JavaScript engine (V8) version and platform (Mac OS X 10.13.2).
* Other JavaScript engines, browsers, or platforms may exhibit different performance characteristics for these loops.
* This benchmark only compares the performance of `forEach`, traditional `for` loops, and `for...of` loops; other loop constructs, like `while` loops or `map()`/`filter()` methods, are not included.

**Alternatives**

If you need to compare the performance of different loop constructs, you can modify this benchmark by adding additional test cases for other loop types, such as:

* `while` loops
* `map()`/`filter()` methods (which don't involve traditional looping)
* Other modern JavaScript features like ` reduce()`, `find()`, or `every()`

Keep in mind that each of these alternatives will require its own benchmarking code and results.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.97 Safari/537.36 Vivaldi/1.94.1008.36

Browser/OS: Chrome 62 on Mac OS X 10.13.2

View result in a separate tab

Test name	Executions per second
forEach	9883.5 Ops/sec
for	5447.3 Ops/sec
for of	1780.0 Ops/sec
arrowForEach	10091.3 Ops/sec
forBackward	5717.7 Ops/sec
reverse while	5604.5 Ops/sec

Related benchmarks:

for-vs-foreach-vs-forof (version: 0)

Comparing performance of: forEach vs for vs for of vs arrowForEach vs forBackward vs reverse while

Created: 6 years ago by: Guest

Jump to the latest result

forEach

for

for of

arrowForEach

forBackward

reverse while

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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