Benchmark: Array creation with 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 newArray = [];
	for(var intCtr=0; intCtr<pArray.length; intCtr++) {
      newArray.push(pArray[intCtr]);
	}
	return newArray;
}
function doForEach(pArray) {
	var newArray = [];
	pArray.forEach(function(item) {
      newArray.push(pArray[item]);
	});
  	return newArray
}

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: 6 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:61.0) Gecko/20100101 Firefox/61.0

Browser/OS: Firefox 61 on Mac OS X 10.13

View result in a separate tab

Test name	Executions per second
reduce	74.6 Ops/sec
for loop	63075.7 Ops/sec
forEach	60463.9 Ops/sec

Autogenerated LLM Summary (model llama3.1:latest, generated 2 months ago):

LLMs can make mistakes. Check important info.

Let's dive into the benchmark test cases and results.

**What is being tested?**

The test case measures the performance of three different approaches to creating an array of 1000 random numbers between 1 and 10,000:

1. Using `Array.reduce()`
2. Using a traditional `for` loop
3. Using `Array.forEach()` followed by pushing elements into a new array

**What are the options compared?**

We're comparing three approaches to creating an array of random numbers:

* **Option 1: Array.reduce()**
	+ Pros:
		- Concise and expressive code
		- Can be useful for aggregating data in arrays
	+ Cons:
		- May be slower due to function call overhead (see benchmark results below)
* **Option 2: Traditional `for` loop**
	+ Pros:
		- Generally fast and efficient
		- Easy to understand and implement
	+ Cons:
		- More verbose code compared to `reduce()` or `forEach()`
* **Option 3: Array.forEach() + push elements**
	+ Pros:
		- Can be faster than `reduce()` (see benchmark results below)
		- Still concise and expressive code
	+ Cons:
		- May have overhead from calling the callback function for each iteration

**Library used**

No external libraries are used in this test case.

**Special JavaScript feature or syntax**

None. The test cases use standard JavaScript features and syntax.

**Alternatives**

If you need to create an array of random numbers, here are some alternative approaches:

* Use `Array.from()` with a callback function to generate random numbers.
* Utilize the `Map` data structure to store random numbers as key-value pairs, then convert it to an array using `Array.from()`.
* Employ a library like Lodash or Underscore.js that provides utility functions for working with arrays and random number generation.

**Benchmark results**

The latest benchmark result shows:

* **For loop**: 63,075.69 executions per second (fastest approach)
* **forEach + push elements**: 60,463.91 executions per second
* **Array.reduce()**: 74.62 executions per second (slowest approach)

Note that these results are specific to Firefox 61 on a Mac OS X 10.13 system and may vary depending on the environment, browser, or device used.

Overall, this benchmark test case highlights the importance of choosing the right data structure and algorithm for your use case, as well as considering performance implications when using different approaches in JavaScript programming.

Related benchmarks:

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

A test pushing 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>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated 2 months ago):