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

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 doLoop(pArray) {
	var accum = 0;
	for(var intCtr=0; intCtr<pArray.length; intCtr++) {
		accum += pArray[intCtr];
	}
	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 doLoop(pArray) {    var accum = 0;    for(var intCtr=0; intCtr<pArray.length; intCtr++) {        accum += pArray[intCtr];    }    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 = doLoop(arrRandom);
var loopResult=0;
loopResult = doLoop(arrRandom);
forEach
var forEachResult=0 forEachResult = doForEach(arrRandom)
var forEachResult=0
forEachResult = doForEach(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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 15 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:135.0) Gecko/20100101 Firefox/135.0

Browser/OS: Firefox 135 on Windows

View result in a separate tab

Test name	Executions per second
reduce	510353.0 Ops/sec
for loop	996292.5 Ops/sec
forEach	138823.5 Ops/sec

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

Let's break down the provided JSON and explain what's being tested.

Benchmark Definition

The benchmark is comparing three different approaches to sum an array of 1000 random numbers:

Array.reduce(): A method that applies a reduction function to each element in the array, accumulating the result.
for loop: A traditional loop that iterates over the array, adding each element to a running total.
Array.forEach(): A method that calls a provided callback function for each element in the array.

Options being compared

The three options are being compared in terms of their performance (measured by "ExecutionsPerSecond") on a specific browser and device platform combination.

Pros and Cons

Array.reduce(): This approach is concise and can be more memory-efficient than traditional loops, as it only requires a single accumulator variable. However, it may not be suitable for very large arrays or performance-critical applications.
for loop: This approach is straightforward and easy to understand, but it can be slower and more memory-intensive than Array.reduce(), especially for large arrays.
Array.forEach(): This approach is similar to the traditional loop, but it's often considered more elegant and easier to read. However, it may not be as performant as the other two options.

Library usage

The benchmark uses the following libraries:

None explicitly mentioned in the JSON, but the Math.random() function is used for generating random numbers.
No external libraries are required for this specific benchmark.

Special JS features/syntax

There's no special JavaScript feature or syntax being tested in this benchmark. The code uses standard JavaScript syntax and built-in functions.

Other alternatives

If you're interested in exploring alternative approaches, consider the following:

Using Array.prototype.every() or Array.prototype.some() instead of forEach(), which can provide similar results but with different performance characteristics.
Using a parallel processing library (e.g., Web Workers) to run multiple iterations of each benchmark simultaneously, which can improve overall performance and provide more accurate comparisons.

Keep in mind that these alternatives may require significant changes to the benchmark code and might not be suitable for all use cases.

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested.

**Benchmark Definition**

The benchmark is comparing three different approaches to sum an array of 1000 random numbers:

1. `Array.reduce()`: A method that applies a reduction function to each element in the array, accumulating the result.
2. `for` loop: A traditional loop that iterates over the array, adding each element to a running total.
3. `Array.forEach()`: A method that calls a provided callback function for each element in the array.

**Options being compared**

The three options are being compared in terms of their performance (measured by "ExecutionsPerSecond") on a specific browser and device platform combination.

**Pros and Cons**

* **`Array.reduce()`**: This approach is concise and can be more memory-efficient than traditional loops, as it only requires a single accumulator variable. However, it may not be suitable for very large arrays or performance-critical applications.
* **`for` loop**: This approach is straightforward and easy to understand, but it can be slower and more memory-intensive than `Array.reduce()`, especially for large arrays.
* **`Array.forEach()`**: This approach is similar to the traditional loop, but it's often considered more elegant and easier to read. However, it may not be as performant as the other two options.

**Library usage**

The benchmark uses the following libraries:

* None explicitly mentioned in the JSON, but the `Math.random()` function is used for generating random numbers.
* No external libraries are required for this specific benchmark.

**Special JS features/syntax**

There's no special JavaScript feature or syntax being tested in this benchmark. The code uses standard JavaScript syntax and built-in functions.

**Other alternatives**

If you're interested in exploring alternative approaches, consider the following:

* Using `Array.prototype.every()` or `Array.prototype.some()` instead of `forEach()`, which can provide similar results but with different performance characteristics.
* Using a parallel processing library (e.g., Web Workers) to run multiple iterations of each benchmark simultaneously, which can improve overall performance and provide more accurate comparisons.

Keep in mind that these alternatives may require significant changes to the benchmark code and might not be suitable for all use cases.

Related benchmarks:

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

A test summing 1000 random numbers, 1 - 10000

Comparing performance of: reduce vs for loop vs forEach

Created: 7 years ago by: Guest

Jump to the latest result

reduce

for loop

forEach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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