Benchmark: reduce vs for loop vs for..of loop vs forEach 1000 count

Script Preparation code:

// Create an array of 1000 random intergers between 0 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, len=pArray.length; intCtr<len; intCtr++) {
		accum += pArray[intCtr];
	}
	return accum;
}
function doForLoop(pArray) {
	var accum = 0;
	for (var item of pArray) {
		accum += item;
	}
	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)
for..of loop
var loopResult=0; loopResult = doForLoop(arrRandom);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
for loop
forEach
for..of loop

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmarking test and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The test consists of four individual benchmarks: `reduce`, `for loop`, `forEach`, and `for..of loop`. Each benchmark measures the performance of a different way to add up 1,000 random numbers in an array. The test uses JavaScript as the programming language.

**Tested Approaches**

Here's what each approach does:

1. **Reduce**: Uses the built-in `Array.prototype.reduce()` method with a custom callback function (`reduceCallback`) that adds two numbers together.
2. **For Loop**: Uses a traditional `for` loop to iterate through the array and add up the values.
3. **ForEach**: Uses the `Array.prototype.forEach()` method with an anonymous callback function to iterate through the array and add up the values.
4. **For..of Loop**: Uses the `for...of` loop syntax, which is a newer iteration of the traditional `for` loop, to iterate through the array and add up the values.

**Comparison**

The test compares the performance of these four approaches on different browsers (Chrome 111) with various device platforms (Desktop) and operating systems (Windows). The results are measured in executions per second.

**Pros and Cons**

Here's a brief summary of the pros and cons for each approach:

1. **Reduce**:
	* Pros: Highly optimized by the browser, can take advantage of hardware acceleration.
	* Cons: Limited control over the iteration process, may not be suitable for complex calculations.
2. **For Loop**:
	* Pros: Provides direct control over the iteration process, suitable for complex calculations.
	* Cons: May not be as efficient as other methods, can lead to performance issues if not optimized correctly.
3. **ForEach**:
	* Pros: Easy to implement and maintain, suitable for simple calculations.
	* Cons: May have lower performance compared to other methods, can introduce overhead due to callback invocation.
4. **For..of Loop**:
	* Pros: Newer syntax, easy to read and maintain, can be more efficient than traditional `for` loops.
	* Cons: Limited control over the iteration process, may not be suitable for complex calculations.

**Library and Special Features**

The test uses built-in JavaScript libraries and features:

1. **Array.prototype.reduce()**: A standard array method that applies a callback function to each element in an array.
2. **Array.prototype.forEach()**: A standard array method that executes a callback function once for each element in an array.

No special JavaScript features or syntax are used beyond what's required by the standard library.

**Alternatives**

If you're looking for alternatives, consider:

1. **CycloneJS**: An alternative to `Array.prototype.reduce()` and other array methods.
2. **Fibers**: A concurrency model that allows for efficient parallel execution of tasks, potentially improving performance in certain scenarios.
3. **Web Workers**: A mechanism for running JavaScript code in separate threads, allowing for more efficient computation and improved performance.

Keep in mind that the best approach depends on your specific use case and requirements. The test provided by MeasureThat.net aims to give a general idea of the relative performance characteristics of different approaches, but you may need to experiment with different solutions to find the most suitable one for your particular needs.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 111 on Windows

View result in a separate tab

Test name	Executions per second
reduce	84922.6 Ops/sec
for loop	1052096.9 Ops/sec
forEach	436665.6 Ops/sec
for..of loop	652978.9 Ops/sec

Related benchmarks:

reduce vs for loop vs for..of loop vs forEach 1000 count (version: 0)

A test adding 1000 random numbers

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

Created: 3 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 25 days ago):