Benchmark: forEach vs reduce vs map vs filter vs for vs while

Script Preparation code:

var arr = [];
for (var i = 0; i < 12345; i++) {
  arr[i] = i;
}

function someFn(i) {
  return (i * 3 * 8 / 1200 * 0.002 / 40 * 0.2);
}

var sumForEach = 0,
  sumReduce = 0,
  sumMap = 0,
  sumFilter = 0,
  sumFor = 0,
  sumWhile = 0;

Tests:

forEach
arr.forEach(item => sumForEach += someFn(item));
reduce
sumReduce = arr.reduce((lastValue, item) => { return sumReduce += someFn(item); });
map
arr.map(item => (sumMap += someFn(item)));
filter
arr.filter(item => (sumFilter += someFn(item)));
for
for (var j = 0; j < arr.length; j++) { sumFor += arr[j]; }
while
var l = arr.length; var i = 0; while (i < l) { sumWhile += arr[i]; i++; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
reduce
map
filter
for
while

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested in this benchmark.

The main task of the benchmark is to measure the performance of different iteration techniques in JavaScript: `forEach`, `reduce`, `map`, `filter`, `for`, and `while`. The test creates an array of 12345 elements, initializes a variable `sum` to store the sum, and defines a function `someFn` that calculates a value based on the input.

The test cases compare the performance of each iteration technique by executing the same code with the same initial conditions. The results are measured in terms of executions per second.

Now, let's analyze the options being compared:

1. **`forEach`**: This method iterates over an array using the `for...of` loop (not explicitly used in this benchmark) and calls a provided function for each element.
	* Pros: concise and expressive way to iterate over arrays, can be used with callback functions or arrow functions.
	* Cons: can lead to slower performance due to the overhead of creating an array of arguments or context objects.
2. **`reduce`**: This method iterates over an array using a reduction function that is applied to each element.
	* Pros: concise and efficient way to iterate over arrays, allows for accumulation of values.
	* Cons: can be less readable than other methods, and the accumulator value can become large for large datasets.
3. **`map`**: This method creates a new array by applying a transformation function to each element.
	* Pros: concise and expressive way to transform arrays, returns a new array without modifying the original one.
	* Cons: can lead to slower performance due to the overhead of creating a new array, especially for large datasets.
4. **`filter`**: This method creates a new array by filtering elements based on a provided function.
	* Pros: concise and expressive way to filter arrays, returns a new array without modifying the original one.
	* Cons: can lead to slower performance due to the overhead of creating a new array, especially for large datasets.
5. **`for`**: This method uses an explicit loop to iterate over an array using an index variable.
	* Pros: can be more readable and controlled than other methods, allows for easy iteration over arrays with specific indices or conditions.
	* Cons: can lead to slower performance due to the overhead of indexing into arrays, especially for large datasets.
6. **`while`**: This method uses a conditional loop to iterate over an array using an index variable.
	* Pros: can be more readable and controlled than other methods, allows for easy iteration over arrays with specific conditions or indices.
	* Cons: can lead to slower performance due to the overhead of indexing into arrays, especially for large datasets.

Other considerations:

* The use of a large dataset (12345 elements) can affect the performance results, as it requires more memory and computational resources.
* The `someFn` function is not optimized for performance, which may impact the overall benchmark results. A more efficient implementation could potentially improve the performance of each iteration technique.

As for libraries or frameworks, there are no notable ones mentioned in this benchmark definition. However, some modern JavaScript frameworks like React or Angular might use these methods internally and provide additional optimizations.

Some special JS features or syntax used in this benchmark include:

* The `for...of` loop is not explicitly used, but the `forEach` method uses a similar syntax to iterate over arrays.
* The `reduce`, `map`, and `filter` methods are part of the ECMAScript 2015 (ES6) standard.

Other alternatives for these iteration techniques include:

* Using `for...in` or `for...of` loops with array indices for iterating over arrays.
* Using libraries like Lodash or Ramda to provide additional functional programming utilities and optimizations.
* Implementing custom iteration algorithms using native JavaScript features, such as Web Workers or WebGL.

Note that this benchmark is designed to test the performance of different iteration techniques in JavaScript. The specific results may vary depending on the browser, hardware, and other factors.

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36

Browser/OS: Chrome 93 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
forEach	347.7 Ops/sec
reduce	348.9 Ops/sec
map	336.4 Ops/sec
filter	339.4 Ops/sec
for	298.6 Ops/sec
while	381.9 Ops/sec

Related benchmarks:

forEach vs reduce vs map vs filter vs for vs while (version: 0)

Comparing performance of: forEach vs reduce vs map vs filter vs for vs while

Created: 4 years ago by: Guest

Jump to the latest result

forEach

reduce

map

filter

for

while

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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