Benchmark: forEach vs reduce vs map vs filter vs forof

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)));
forof
for (var x of arr) { sumFor += x; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
reduce
map
filter
forof

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0

Browser/OS: Firefox 83 on Windows

View result in a separate tab

Test name	Executions per second
forEach	3010.0 Ops/sec
reduce	2950.0 Ops/sec
map	2266.8 Ops/sec
filter	1988.2 Ops/sec
forof	2150.6 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmarking test case, designed to compare the performance of different iteration methods in JavaScript: `forEach`, `reduce`, `map`, `filter`, and `for-of` loops.

**Iteration Methods Compared**

Each iteration method is compared on its own, with the same input data (an array of 12,345 elements). The performance differences between these methods will help users understand which approach is most efficient for their specific use cases.

**Options Compared**

1. **`forEach`**: Iterates over the array using a traditional `for` loop with an index variable.
2. **`reduce`**: Accumulates a value by applying a function to each element in the array, reducing it to a single output value.
3. **`map`**: Returns a new array with the results of applying a function to each element in the original array.
4. **`filter`**: Creates a new array with all elements that pass a test implemented as a function.
5. **`for-of` loops** (not to be confused with traditional `for` loops): Iterates over the array using an iterator, allowing for more concise and expressive code.

**Pros and Cons of Each Approach**

1. **`forEach`**: Pros:
	* Easy to use and understand
	* Fast iteration performance
	* Supports asynchronous iterations (e.g., callback functions)
Cons:
	* Can be slower than other methods due to the need to index into the array
2. **`reduce`**:
	* Pros: Efficient accumulator mechanism, suitable for reducing arrays to single values.
	* Cons: May require more memory usage and complex logic due to its accumulator nature.
3. **`map`**: Pros:
	* Creates a new array with transformed values, avoiding side effects.
	* Supports asynchronous iterations (e.g., callback functions).
Cons:
	* Can be slower than `forEach` due to the creation of a new array.
4. **`filter`**:
	* Pros: Creates a new array with filtered elements, preserving original order.
	* Cons: May require more memory usage and complex logic due to its filtering mechanism.
5. **`for-of` loops**: Pros:
	* More concise and expressive than traditional `for` loops
	* Supports asynchronous iterations (e.g., iterator objects)
Cons:
	* Not as widely supported as other methods, especially in older browsers.

**Special Considerations**

The benchmark does not include any special JavaScript features or syntax that are not applicable to all modern browsers. However, if the test were updated to include such features, it might highlight performance differences between different implementations (e.g., WebAssembly or ES6+ syntax).

**Other Alternatives**

Some other iteration methods in JavaScript include:

* `every` and `some`: Iterate over an array using a predicate function.
* `find()` and `findIndex()`: Find the first element that satisfies a condition, returning its index.

These alternatives are not included in this benchmark, but may be worth exploring depending on specific use cases.

Related benchmarks:

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

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

Created: 4 years ago by: Guest

Jump to the latest result

forEach

reduce

map

filter

forof

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