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

Script Preparation code:

// Create an array of 1000 random intergers between 1 and 10000
var arrRandom = [];
for(var intCtr=0; intCtr<500000; 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);
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:

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.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The benchmark compares three approaches to sum up 500,000 random integers between 1 and 10,000:

1. `Array.prototype.reduce()`
2. `For loop` (a traditional iterative approach)
3. `Array.prototype.forEach()` (along with a callback function)

**Options Compared**

Here's a brief explanation of each option:

* **`Array.prototype.reduce()`**: This method applies a user-supplied function to an array, accumulating a value from the elements in a cumulative manner, from left to right, so as to reduce it to a single output value. In this benchmark, the callback function simply adds two numbers.
* **For loop**: A traditional iterative approach using a `for` statement to iterate over the array and sum up its elements.
* **`Array.prototype.forEach()`**: This method calls a provided function once for each element in an array, from left to right. In this benchmark, we use it with a callback function that adds two numbers.

**Pros and Cons**

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

* **`Array.prototype.reduce()`**:
	+ Pros: concise, efficient (can be optimized by the engine), and easy to implement.
	+ Cons: might not be as straightforward for beginners, can be slower than traditional loops in some cases (depending on browser optimization).
* **For loop**:
	+ Pros: widely supported, easy to understand, and flexible (can be used with any type of data structure).
	+ Cons: more verbose than `reduce()`, and might lead to performance issues if not optimized correctly.
* **`Array.prototype.forEach()`**:
	+ Pros: concise and expressive (easy to implement), and can be useful for other array operations beyond summing up values.
	+ Cons: can be slower than traditional loops in some cases, as it involves an extra function call.

**Library and Special JS Features**

In this benchmark, we're using the following libraries:

* None explicitly mentioned, but `Array.prototype` is being used extensively.

No special JavaScript features are used beyond the standard library functions (`Math.random()`, `Array.prototype.reduce()`, `Array.prototype.forEach()`).

**Other Alternatives**

If you want to explore alternative approaches or optimize the existing ones, consider the following:

* **`Set`**: You could use a `Set` data structure to sum up unique values (e.g., for a distinct sum).
* **Parallel processing**: For very large arrays, using parallel processing techniques (like Web Workers) might significantly speed up computations.
* **Just-In-Time (JIT) compilation**: Some engines (like SpiderMonkey in Firefox) use JIT compilation to optimize performance-critical code.

Keep in mind that each approach has its strengths and weaknesses, and the best choice depends on your specific requirements, performance constraints, and coding style preferences.

Related benchmarks:

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

A test summing 1000 random numbers, 1 - 10000

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>

Fastest: N/A

Slowest: N/A

No previous run results

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