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

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

Related benchmarks:

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

Comparing performance of: forEach vs reduce vs map vs filter

Created: 8 years ago by: Guest

Jump to the latest result

forEach

reduce

map

filter

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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