Benchmark: for, for of, forEach, and reduce. Each with and without reduced variable re-declarations.

Script Preparation code:

var array = [];
(function(theArray) {
  for (var i = 0, L = 10000; i < L; i += 1) {
    array.push({
      creationIndex: i,
      someStringifiedNumber: (Date.now() + '|' + Math.random())
    });
  }
})(array);
var result;

Tests:

for
var someValuesArray = []; for (var i = 0, L = array.length; i < L; i++) { var someVar = array[i]; var someValue = someVar.creationIndex + someVar.someStringifiedNumber; someValuesArray.push(someValue); } result = someValuesArray;
for (less closure)
var someValuesArray = []; var someVar; var someValue; for (var i = 0, L = array.length; i < L; i++) { someVar = array[i]; someValue = someVar.creationIndex + someVar.someStringifiedNumber; someValuesArray.push(someValue); } result = someValuesArray;
for of
var someValuesArray = []; for (var someVar of array) { var someValue = someVar.creationIndex + someVar.someStringifiedNumber; someValuesArray.push(someValue); } result = someValuesArray;
for of (less closure)
var someValuesArray = []; var someValue for (var someVar of array) { someValue = someVar.creationIndex + someVar.someStringifiedNumber; someValuesArray.push(someValue); } result = someValuesArray;
forEach
var someValuesArray = []; array.forEach(function(someVar) { var someValue = someVar.creationIndex + someVar.someStringifiedNumber; someValuesArray.push(someValue); }); result = someValuesArray;
forEach (less closure)
var someValuesArray = []; var someValue; array.forEach(function(someVar) { someValue = someVar.creationIndex + someVar.someStringifiedNumber; someValuesArray.push(someValue); }); result = someValuesArray;
reduce
var someValuesArray = array.reduce(function(valuesArray, someVar) { var someValue = someVar.creationIndex + someVar.someStringifiedNumber; valuesArray.push(someValue); return valuesArray; }, []); result = someValuesArray;
reduce (less closure)
var someValuesArray = []; var someValue; array.reduce(function(valuesArray, someVar) { someValue = someVar.creationIndex + someVar.someStringifiedNumber; valuesArray.push(someValue); return valuesArray; }, someValuesArray); result = someValuesArray;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for
for (less closure)
for of
for of (less closure)
forEach
forEach (less closure)
reduce
reduce (less closure)

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmark that compares the performance of four different loop constructs: `for`, `for of`, `forEach` with and without reduced variable re-declarations, and `reduce`.

**Loop Constructs Compared**

1. **For**: A traditional loop construct with a declared variable (`i`) and an increment statement.
2. **For of**: A loop construct that iterates over an array using the `of` keyword.
3. **ForEach (with closure)**: A loop construct that uses the `forEach` method with a callback function that has access to the loop's variable (`i`).
4. **ForEach (without closure)**: A loop construct that uses the `forEach` method without providing a callback function, effectively using the loop's variable (`i`) directly.
5. **Reduce**: A reduction loop that applies a binary function to each element of an array.

**Performance Comparison**

The benchmark measures the number of executions per second for each loop construct on a mobile device running iOS 13.7. The results show that:

* `reduce` has the highest performance, followed by `for of`, `forEach (with closure)`, and `forEach (without closure)`.
* `For of` outperforms `forEach` with and without closures.
* `ForEach (with closure)` and `ForEach (without closure)` have similar performance.

**Notes on Performance**

The performance differences between the loop constructs are likely due to:

* The `for of` construct's ability to avoid the overhead of a traditional loop with an increment statement.
* The use of closures in `forEach` methods, which can lead to performance improvements due to optimized function call mechanisms.
* The reduction loop's inherent efficiency, as it only requires a single pass through the array.

**Implications and Recommendations**

These results suggest that:

* When performance is critical, consider using `for of` or `reduce`, as they tend to be faster than traditional loops.
* Use `forEach (with closure)` when possible, as it can provide better performance due to optimized function call mechanisms.
* Avoid using closures in `forEach` methods, as it may not lead to significant performance improvements.

Keep in mind that these results are specific to the mobile device and iOS 13.7 environment. Benchmarking should always be done on a representative set of platforms and devices to ensure accurate results.

Related benchmarks:

for, for of, forEach, and reduce. Each with and without reduced variable re-declarations. (version: 1)

Compare loop performance

Comparing performance of: for vs for (less closure) vs for of vs for of (less closure) vs forEach vs forEach (less closure) vs reduce vs reduce (less closure)

Created: 5 years ago by: Registered User

Jump to the latest result

for

for (less closure)

for of

for of (less closure)

forEach

forEach (less closure)

reduce

reduce (less closure)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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