Benchmark: Array.reduce vs for loop vs Array.forEach vs for of loop 2

Script Preparation code:

//Create an array of 1000 random intergers between 1 and 10000
var arrRandom = [];
for(var intCtr=0; intCtr<1000; intCtr++) {
  arrRandom.push(Math.floor(Math.random() * Math.floor(10000)));
}

function reduceCallback(accum, curr) {
	return accum+curr;
}

function doRedeuce(pArray) {
	return pArray.reduce(reduceCallback);
}
function doForLoop(pArray) {
	var accum = 0;
	var arrLength = pArray.length;
	for(var intCtr=0; intCtr<arrLength; intCtr++) {
		accum += pArray[intCtr];
	}
	return accum;
}
function doForOfLoop(pArray) {
	var accum = 0;
	for(var value of pArray) {
		accum += value;
	}
	return accum;
}
function doForEach(pArray) {
	var accum = 0;
	pArray.forEach(function(item) {
		accum += item;
	});
}

​x
 
//Create an array of 1000 random intergers between 1 and 10000var arrRandom = [];for(var intCtr=0; intCtr<1000; intCtr++) {  arrRandom.push(Math.floor(Math.random() * Math.floor(10000)));}​function reduceCallback(accum, curr) {    return accum+curr;}​function doRedeuce(pArray) {    return pArray.reduce(reduceCallback);}function doForLoop(pArray) {    var accum = 0;    var arrLength = pArray.length;    for(var intCtr=0; intCtr<arrLength; intCtr++) {        accum += pArray[intCtr];    }    return accum;}function doForOfLoop(pArray) {    var accum = 0;    for(var value of pArray) {        accum += value;    }    return accum;}function doForEach(pArray) {    var accum = 0;    pArray.forEach(function(item) {        accum += item;    });}

Tests:

reduce
var redeuceResult=0; redeuceResult = doRedeuce(arrRandom);
var redeuceResult=0;
redeuceResult = doRedeuce(arrRandom);
for loop
var loopResult=0; loopResult = doForLoop(arrRandom);
var loopResult=0;
loopResult = doForLoop(arrRandom);
forEach
var forEachResult=0 forEachResult = doForEach(arrRandom)
var forEachResult=0
forEachResult = doForEach(arrRandom)
for of loop
var forOfResult=0 forOfResult = doForOfLoop(arrRandom)
var forOfResult=0
forOfResult = doForOfLoop(arrRandom)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
reduce
for loop
forEach
for of loop

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 70 on Windows

View result in a separate tab

Test name	Executions per second
reduce	44698.5 Ops/sec
for loop	656834.1 Ops/sec
forEach	384501.5 Ops/sec
for of loop	557607.2 Ops/sec

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

Let's break down the benchmark and its options.

Benchmark Overview

The benchmark is designed to compare the performance of four different approaches for summing up an array of random numbers:

Array.prototype.reduce()
Traditional for loop
Array.prototype.forEach() (note: this method does not return the accumulated value, but we're using it as if it did)
for...of loop

Options Compared

The benchmark compares the performance of each option by executing them multiple times and measuring their execution time per second.

reduce(): uses an arrow function to specify the callback function for the reduction
Traditional for loop: uses a traditional for loop with a counter variable
forEach() (as if it returned the accumulated value): uses the forEach() method without modifying it, as if it were returning the accumulated value
for...of loop: uses a for...of loop to iterate over the array

Pros and Cons of Each Approach

reduce():
- Pros: concise and expressive code, avoids explicit loops
- Cons: might be less efficient due to additional overhead
Traditional for loop:
- Pros: efficient and well-established pattern, easy to understand
- Cons: more verbose than reduce() or forEach()
forEach() (as if it returned the accumulated value):
- Pros: similar to reduce() in syntax and intent, avoids explicit loops
- Cons: not a standard method of Array.prototype.forEach(), might be less efficient due to additional overhead
for...of loop:
- Pros: concise and expressive code, easy to understand
- Cons: relatively new feature, might not be supported by older browsers or environments

Library Usage

In this benchmark, the reduce() method uses an arrow function to specify the callback function for the reduction.

Special JS Feature/Syntax

The benchmark does not use any special JavaScript features or syntax that are not widely supported (e.g., ES6+ syntax). However, it's worth noting that the for...of loop is a relatively new feature that was introduced in ECMAScript 2015.

Alternative Approaches

Other alternatives for summing up an array of numbers could include:

Using Array.prototype.map() and then calling reduce() on the resulting mapped array
Using a while loop or other iterative approach
Using a functional programming library like Lodash

These alternative approaches might have different performance characteristics, syntax requirements, and ease of use compared to the options tested in this benchmark.

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its options.

**Benchmark Overview**

The benchmark is designed to compare the performance of four different approaches for summing up an array of random numbers:

1. `Array.prototype.reduce()`
2. Traditional `for` loop
3. `Array.prototype.forEach()` (note: this method does not return the accumulated value, but we're using it as if it did)
4. `for...of` loop

**Options Compared**

The benchmark compares the performance of each option by executing them multiple times and measuring their execution time per second.

* `reduce()`: uses an arrow function to specify the callback function for the reduction
* Traditional `for` loop: uses a traditional `for` loop with a counter variable
* `forEach()` (as if it returned the accumulated value): uses the `forEach()` method without modifying it, as if it were returning the accumulated value
* `for...of` loop: uses a `for...of` loop to iterate over the array

**Pros and Cons of Each Approach**

1. `reduce()`:
	* Pros: concise and expressive code, avoids explicit loops
	* Cons: might be less efficient due to additional overhead
2. Traditional `for` loop:
	* Pros: efficient and well-established pattern, easy to understand
	* Cons: more verbose than `reduce()` or `forEach()`
3. `forEach()` (as if it returned the accumulated value):
	* Pros: similar to `reduce()` in syntax and intent, avoids explicit loops
	* Cons: not a standard method of `Array.prototype.forEach()`, might be less efficient due to additional overhead
4. `for...of` loop:
	* Pros: concise and expressive code, easy to understand
	* Cons: relatively new feature, might not be supported by older browsers or environments

**Library Usage**

In this benchmark, the `reduce()` method uses an arrow function to specify the callback function for the reduction.

**Special JS Feature/Syntax**

The benchmark does not use any special JavaScript features or syntax that are not widely supported (e.g., ES6+ syntax). However, it's worth noting that the `for...of` loop is a relatively new feature that was introduced in ECMAScript 2015.

**Alternative Approaches**

Other alternatives for summing up an array of numbers could include:

* Using `Array.prototype.map()` and then calling `reduce()` on the resulting mapped array
* Using a `while` loop or other iterative approach
* Using a functional programming library like Lodash

These alternative approaches might have different performance characteristics, syntax requirements, and ease of use compared to the options tested in this benchmark.

Related benchmarks:

Array.reduce vs for loop vs Array.forEach vs for of loop 2 (version: 0)

A test summing 1000 random numbers, 1 - 10000

Comparing performance of: reduce vs for loop vs forEach vs for of loop

Created: 6 years ago by: Guest

Jump to the latest result

reduce

for loop

forEach

for of loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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