Benchmark: forEach vs reduce vs map vs filter vs for eac2!1!

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 sumReduce += someFn(item); });
map
arr.map(item => (sumMap += someFn(item)));
filter
arr.filter(item => (sumFilter += someFn(item)));
for
for (var j of arr) { sumFor += someFn(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

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

LLMs can make mistakes. Check important info.

I'd be happy to explain what's being tested in the provided benchmark.

**Benchmark Overview**

The benchmark measures the performance of four different JavaScript iteration methods: `forEach`, `reduce`, `map`, and `filter`. The test case uses a large array with 12,345 elements, which is populated with incremental values from 0 to 11,445. Each element's value is calculated using a simple function, `someFn(i)`, which multiplies `i` by various constants.

**Iteration Methods**

Here's a brief overview of each iteration method:

1. **forEach**: This method iterates over the array, executing the provided callback function for each element. In this test case, the `forEach` method adds the result of `someFn(item)` to a running total, `sumForEach`.
2. **reduce**: This method applies a reduction function to an accumulator and each element in the array. The callback function takes two arguments: the accumulator and the current element. In this test case, the `reduce` method adds the result of `someFn(item)` to an initial value (not explicitly defined) and returns the total.
3. **map**: This method creates a new array with the results of applying a transformation function to each element in the original array. In this test case, the `map` method adds the result of `someFn(item)` to a running total, `sumMap`.
4. **filter**: This method creates a new array with only the elements that pass the provided test. The callback function returns `true` if an element should be included in the new array, and `false` otherwise. In this test case, the `filter` method adds the result of `someFn(item)` to a running total, `sumFilter`.
5. **for-each** (not explicitly listed): This is an older iteration method that's not commonly used today. It iterates over an array using a traditional `for` loop.

**Comparison**

The benchmark compares the performance of these four iteration methods:

* `forEach`: Iterates over the array, executing a callback function for each element.
* `reduce`: Applies a reduction function to an accumulator and each element in the array.
* `map`: Creates a new array with transformed elements.
* `filter`: Creates a new array with filtered elements.

**Pros and Cons**

Here are some pros and cons of each iteration method:

1. **forEach**:
	* Pros: Easy to use, intuitive syntax, suitable for simple transformations.
	* Cons: Can be slower than other methods due to the callback function overhead.
2. **reduce**:
	* Pros: Suitable for cumulative calculations, can handle arrays with no elements.
	* Cons: Can be less readable due to the accumulator and callback function.
3. **map**:
	* Pros: Creates a new array with transformed elements, suitable for simple transformations.
	* Cons: Can be slower than `forEach` due to the creation of a new array.
4. **filter**:
	* Pros: Suitable for creating arrays with filtered elements, can be faster than `forEach`.
	* Cons: Requires explicit callback function for each element.

**Library**

There is no specific library used in this benchmark, as it's focused on comparing built-in JavaScript iteration methods.

**Special JS Feature or Syntax**

The benchmark doesn't use any special JavaScript features or syntax beyond the standard array and object literals. However, it does use a non-standard value (0x1!) for the `forEach` test case, which is likely done to create a unique identifier for each execution.

**Alternatives**

Other alternatives to these iteration methods include:

* Using `for-each` loops or `while` loops for manual iteration.
* Using libraries like Lodash or Ramda for more functional programming approaches (e.g., `map`, `filter`, and `reduce` functions).
* Optimizing array performance using techniques like chunking, caching, or parallel processing.

Overall, this benchmark provides a useful comparison of the performance characteristics of four common JavaScript iteration methods, helping developers understand the trade-offs involved in choosing the right approach for their specific use cases.

Latest run results:

Run details: (Test run date: 8 months ago)

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

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
forEach	283.6 Ops/sec
reduce	286.2 Ops/sec
map	284.1 Ops/sec
filter	259.4 Ops/sec
for	276.4 Ops/sec

Related benchmarks:

forEach vs reduce vs map vs filter vs for eac2!1! (version: 0)

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

Created: 8 months 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.2:3b, generated one month ago):