Benchmark: forEach vs reduce vs map vs filter

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;

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
forEach
reduce
map
filter

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmarking test case, specifically designed to compare the performance of four different array operations: `forEach`, `reduce`, `map`, and `filter`. The benchmark measures how many executions per second each operation can handle on a given input.

**Array Operations Comparison**

1. **`forEach`**: Iterates over an array using a callback function, executing it for each element.
2. **`reduce`**: Reduces an array to a single value by applying a callback function to each element in order.
3. **`map`**: Creates a new array with the results of applying a callback function to each element in the original array.
4. **`filter`**: Creates a new array with all elements that pass a provided test.

**Options Comparison and Pros/Cons**

*   **`forEach`**:
    *   **Pros**: Simple, easy to understand, and suitable for simple operations like iterating over an array and performing a single action per element.
    *   **Cons**: Not optimized for performance; can be slower than other methods due to the overhead of callback functions and iteration checks.
*   **`reduce`**:
    *   **Pros**: Efficient and optimized for performance, suitable for reducing arrays to a single value. Can handle complex operations by chaining multiple reductions.
    *   **Cons**: More complex and less intuitive than `forEach`, requires careful handling of initial values, identity values, and error handling.
*   **`map`**:
    *   **Pros**: Creates a new array with transformed elements, suitable for simple transformations. Can be faster than `forEach` due to the elimination of unnecessary overhead.
    *   **Cons**: Requires creating a new array, which can lead to memory allocation issues and higher performance costs if the resulting array is large.
*   **`filter`**:
    *   **Pros**: Efficiently filters out unwanted elements from an array, suitable for simple filtering operations. Can be faster than `forEach` due to the elimination of unnecessary overhead.
    *   **Cons**: Less flexible than `reduce`, requires careful handling of edge cases and performance.

**Library Usage (None in this case)**

This benchmark does not use any external libraries, focusing solely on native JavaScript operations for comparison.

**Special JS Features/ Syntax**

The test makes use of modern JavaScript features such as arrow functions (`item => sumForEach += someFn(item)`), template literals (`var arr = [];`), and block scope (using `var` instead of `let` or `const`). These features are commonly used in modern JavaScript development but may not be supported by older browsers.

**Other Alternatives**

Alternative array operations that could have been compared include:

*   **`every`**: Tests whether all elements in an array pass a test.
*   **`some`**: Returns true if at least one element in an array passes a test.
*   **`indexOf`, `lastIndexOf`, and `findIndex`**: Searches for specific elements or indices within arrays.

However, these methods are not as commonly used for general array operations and were not included in this benchmarking test.

Latest run results:

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

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

Browser/OS: Chrome 106 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
forEach	373.1 Ops/sec
reduce	380.5 Ops/sec
map	360.1 Ops/sec
filter	366.1 Ops/sec

Related benchmarks:

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

Comparing performance of: forEach vs reduce vs map vs filter

Created: 6 years ago by: Guest

Jump to the latest result

forEach

reduce

map

filter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):