Benchmark: forEach vs reduce vs map vs filter vs for2

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;

Tests:

forEach
arr.forEach(item => sumForEach += someFn(item));
reduce
sumReduce = arr.reduce((lastValue, item) => { return lastValue += someFn(item); }, 0);
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]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
reduce
map
filter
for

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 81 on Mac OS X 10.15.4

View result in a separate tab

Test name	Executions per second
forEach	253.9 Ops/sec
reduce	750.9 Ops/sec
map	265.3 Ops/sec
filter	252.5 Ops/sec
for	228.7 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark definition and results.

**Benchmark Definition**

The benchmark is testing the performance of five different methods for iterating over an array and performing some computation on each item:

1. `forEach`: using the `forEach` method to iterate over the array and add up the result of a function `someFn(i)` applied to each item.
2. `reduce`: using the `reduce` method to iterate over the array and accumulate a value by applying the `someFn(i)` function to each item.
3. `map`: using the `map` method to create a new array with the result of applying the `someFn(i)` function to each item, but not adding up the results (the `sumMap` variable is used to keep track of this).
4. `filter`: using the `filter` method to filter out some items based on the result of the `someFn(i)` function, and add up the results of the remaining items.
5. `for`: a classic `for` loop iterating over the array and adding up the result of the `someFn(i)` function applied to each item.

**Test Case Library**

No special library is used in this benchmark. The code only relies on standard JavaScript methods like `forEach`, `reduce`, `map`, `filter`, and good old `for`.

**JavaScript Features/Syntax Used**

The following features are used:

* Arrow functions: e.g., `item => sumForEach += someFn(item)`
* Destructuring assignment: not explicitly used, but implied in the code
* Template literals: not used at all

**Options Compared**

The benchmark compares five different methods for iterating over an array and performing a computation on each item:

1. **forEach**: using the `forEach` method to iterate over the array.
2. **reduce**: using the `reduce` method to accumulate a value by applying a function to each item.
3. **map**: using the `map` method to create a new array with the result of applying a function to each item (not adding up the results).
4. **filter**: using the `filter` method to filter out some items based on the result of a function, and add up the results of the remaining items.
5. **for**: a classic `for` loop iterating over the array.

**Pros/Cons of Each Approach**

Here's a brief summary:

1. **forEach**: simple and efficient, but not suitable for accumulation or transformations that require all previous values.
	* Pros: easy to understand, good performance.
	* Cons: not designed for accumulation or transformations.
2. **reduce**: designed for accumulation and transformations, but can be slower due to function calls on each iteration.
	* Pros: flexible, accumulates values efficiently.
	* Cons: might be slower due to repeated function calls.
3. **map**: suitable for creating a new array with transformed values, but not designed for accumulation or filtering.
	* Pros: easy to understand, good performance.
	* Cons: not designed for accumulation or filtering.
4. **filter**: perfect for filtering out items based on a condition, but might be slower due to repeated function calls.
	* Pros: flexible, efficient filtering.
	* Cons: might be slower due to repeated function calls.
5. **for**: a classic approach that's easy to understand and debug, but can be slower due to explicit iteration and repeated function calls.
	* Pros: simple, easy to understand.
	* Cons: might be slower due to repeated function calls.

**Other Considerations**

When choosing an iteration method, consider the following:

* **Accumulation**: use `reduce` or `forEach` if you need to accumulate a value over all iterations.
* **Filtering**: use `filter` for efficient filtering out items based on a condition.
* **Transformation**: use `map` to create a new array with transformed values, but not for accumulation or filtering.
* **Performance-critical code**: consider using `forEach` or classic `for` loops for performance-critical code, as they might be faster due to fewer function calls.

**Alternatives**

For each iteration method, you can use alternative approaches:

1. **forEach**: instead of `reduce`, use a separate variable to accumulate the value over iterations.
2. **map**: instead of filtering with `filter`, use `map` to create a new array with only the desired items.
3. **for**: consider using a more modern iteration method, like `forEach` or `reduce`.

That's it! This summary should give you an idea of what each test case is doing and how the different methods compare in terms of performance and usage.

Related benchmarks:

forEach vs reduce vs map vs filter vs for2 (version: 0)

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

Created: 4 years ago by: Guest

Jump to the latest result

forEach

reduce

map

filter

for

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):