Benchmark: reduce vs for loop

Script Preparation code:

var arrRandom = [];
for(var intCtr=0; intCtr<1000; intCtr++) {
  arrRandom.push(Math.floor(Math.random() * Math.floor(10000)));
}
function doRedeuce(pArray) {
	return pArray.reduce(function(accum, curr) {return accum+curr});
}
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);
for loop
var loopResult=0; loopResult = doLoop(arrRandom);
forEach
var forEachResult=0 forEachResult = doForEach(arrRandom)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
for loop
forEach

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
reduce	2685954.5 Ops/sec
for loop	3112817.2 Ops/sec
forEach	2696412.8 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the provided JSON benchmark definition and its various components.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmarking test case, specifically designed to compare the performance of three different approaches for summing an array of numbers:

1.  `reduce()`
2.  For loop
3.  `forEach()` method

These approaches are compared to determine which one is most efficient in terms of execution time.

**Benchmark Preparation Code**

The benchmark preparation code is a JavaScript script that generates an array of 1000 random numbers and defines three functions:

1.  `doRedeuce(pArray)`: Uses the `reduce()` method to sum the elements of the array.
2.  `doLoop(pArray)`: Iterates through the array using a traditional for loop, adding each element to a running total.
3.  `doForEach(pArray)`: Iterates through the array using the `forEach()` method, adding each element to a running total.

The script then assigns the results of each function to variables named after their corresponding names (`redeuceResult`, `loopResult`, and `forEachResult`).

**HTML Preparation Code**

Since there is no HTML preparation code provided, we can assume that this step is skipped or not applicable for this specific benchmark.

**Individual Test Cases**

The individual test cases are defined as an array of objects, each representing a single test. Each object contains two properties:

1.  `Benchmark Definition`: A string representing the JavaScript code that performs the actual benchmarking. This code calls one of the three functions (reduced(), doLoop(arrRandom), or forEach(arrRandom)) and assigns the result to a variable with the same name.
2.  `Test Name`: A string representing the name of the test case.

The provided individual test cases are:

1.  `reduce`
2.  `for loop`
3.  `forEach`

**Latest Benchmark Result**

The latest benchmark result is an array of objects, each containing information about a single execution. The relevant properties include:

*   `Browser`: The name and version of the browser being tested.
*   `DevicePlatform`: The type of device platform (e.g., Desktop).
*   `OperatingSystem`: The operating system being tested.
*   `ExecutionsPerSecond`: The number of executions performed per second.

The provided benchmark result contains data for each test case:

1.  `for loop`
2.  `forEach`
3.  `reduce`

**Options Comparison**

Let's examine the three options compared in this benchmark:

### reduce()

This approach uses the `reduce()` method to sum the elements of the array. The `reduce()` method takes two arguments: an initial value (usually set to 0) and a callback function that combines the current value with each subsequent element.

**Pros:**

*   More concise and expressive code
*   Can be easily parallelized using Web Workers or async/await

**Cons:**

*   May incur overhead due to function call stack usage
*   Less control over iteration order compared to traditional for loops

### For Loop

This approach uses a traditional for loop to iterate through the array, adding each element to a running total.

**Pros:**

*   More control over iteration order and can be optimized using SIMD instructions
*   Can be easier to understand and maintain for developers familiar with traditional for loops

**Cons:**

*   More verbose code compared to reduce()
*   May incur slower execution times due to overhead of manual loop management

### forEach()

This approach uses the `forEach()` method to iterate through the array, adding each element to a running total.

**Pros:**

*   Less control over iteration order compared to traditional for loops
*   Can be more concise and expressive code

**Cons:**

*   May incur overhead due to function call stack usage
*   Less control over performance optimizations compared to reduce() or traditional for loops

**Other Considerations**

When evaluating the performance of these options, it's essential to consider factors such as:

*   Browser support and version compatibility
*   Optimizations available on modern hardware (e.g., SIMD instructions)
*   Potential side effects or memory leaks introduced by certain code paths

Related benchmarks:

reduce vs for loop (version: 0)

A test summing 1000 random numbers

Comparing performance of: reduce vs for loop vs forEach

Created: 6 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 2 months ago):