Benchmark: filter-map vs reduce vs forEach

Script Preparation code:

a = [];
for (i = 0; i < 1000000; i++) a.push(Number(i) / 1000000);
var filtering = x => (x * 114514) % 1 > 0.5;
var mapping = x => x + 0.1919;
var reducing = (acc, x) => {
    var value = mapping(x);
    if (filtering(value)) acc.push(value);
    return acc;
}
var resutForEach = [];
var forEaching = (value) => {
    if (filtering(value)) resutForEach.push(value);
}

Tests:

map-filter
a.filter(filtering).map(mapping);
reduce
a.reduce(reducing,[]);
ForEach
a.forEach(forEaching);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
map-filter
reduce
ForEach

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmarking test case, where users can compare the performance of three different approaches: `filter-map`, `reduce`, and `forEach`. The test is designed to measure the execution time of these approaches on a large dataset.

**Approach Descriptions**

### Filter-Map

This approach combines two methods: `filter` and `map`. The `filter` method is used to filter out elements that do not meet a certain condition, while the `map` method is used to apply a transformation function to each element. In this test case, the `filtering` function is applied to each element in the array, and then the resulting values are mapped through the `mapping` function.

**Pros:**

* Simplified code: Combining two methods into one can lead to more concise code.
* Efficient filtering: The `filter` method is designed for this purpose, making it faster than using a custom implementation.

**Cons:**

* Potential performance overhead: Creating and executing an intermediate array in the `filter` method can add unnecessary overhead.
* Less control over iteration: Since the `map` method is applied after filtering, the order of elements in the resulting array may not be the same as the original array.

### Reduce

This approach uses a single method, `reduce`, to accumulate values in an accumulator. In this test case, the `reducing` function is applied to each element in the array, adding the transformed value (`mapping(x)` ) to the accumulator only if the filtering condition is met.

**Pros:**

* More control over iteration: Since a single method is used, there's more control over how elements are processed.
* Efficient accumulation: The `reduce` method is designed for accumulating values in an array, making it faster than using a custom implementation.

**Cons:**

* Complex code: Using a single method to perform multiple operations can lead to more complex and harder-to-read code.
* Potential performance overhead: Creating and executing an accumulator object can add unnecessary overhead.

### ForEach

This approach uses the `forEach` method, which applies a callback function to each element in an array. In this test case, the `forEaching` function is applied to each element in the array, filtering out elements that do not meet the condition.

**Pros:**

* Simple code: Using a single method with a callback function can lead to more concise and readable code.
* Fast execution: The `forEach` method is designed for executing a callback function on each element, making it fast.

**Cons:**

* Potential performance overhead: Creating and executing an array of functions can add unnecessary overhead.
* Less control over iteration: Since the `forEach` method is applied after filtering, the order of elements in the resulting array may not be the same as the original array.

**Library Descriptions**

In this test case, two libraries are used:

1.  **JavaScript Standard Library:** The standard JavaScript library includes various built-in methods and functions that can be used to perform operations on arrays, such as `filter`, `map`, `forEach`, and `reduce`. In this test case, these methods are used directly in the benchmark.
2.  No external libraries are explicitly mentioned but since there is no other description of a library, we assume standard JavaScript methods.

**Special JS Features/Syntax**

The provided code does not use any special JavaScript features or syntax beyond the standard JavaScript Standard Library methods.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 115 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
map-filter	22.2 Ops/sec
reduce	9.0 Ops/sec
ForEach	11.8 Ops/sec

Related benchmarks:

filter-map vs reduce vs forEach (version: 2)

Comparing performance of: map-filter vs reduce vs ForEach

Created: one year ago by: Registered User

Jump to the latest result

map-filter

reduce

ForEach

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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