Benchmark: Reduce Push vs. flatMap vs 123

Script Preparation code:

var arr = Array(10000).map((x, i) => i)

Tests:

Reduce Push
arr.reduce((acc, x) => { acc.push(x, x); return acc; }, [])
flatMap
arr.flatMap(x => [x, x])
mapFilter
arr.map(x => x).filter(x => !!x)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce Push
flatMap
mapFilter

Fastest: N/A

Slowest: N/A

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/128.0.0.0 Safari/537.36

Browser/OS: Chrome 128 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Reduce Push	99999.3 Ops/sec
flatMap	56006.4 Ops/sec
mapFilter	40353.9 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark is designed to compare the performance of three different JavaScript methods: `reduce()`, `flatMap()`, and `map()` with filtering. The goal is to determine which method is the most efficient for this specific use case.

**Benchmark Definition JSON**

The benchmark definition JSON provides information about the test, including:

* `Name`: The name of the benchmark.
* `Description`: An optional description of the benchmark.
* `Script Preparation Code`: A JavaScript code snippet that prepares the input data for the test. In this case, it creates an array of 10,000 elements using `Array(10000).map((x, i) => i)`.
* `Html Preparation Code`: An optional code snippet that prepares the HTML environment for the test. In this case, it is empty.

**Individual Test Cases**

The individual test cases are defined in a separate JSON array:

1. **Reduce Push**: This test case uses the `reduce()` method with a custom callback function that pushes each element to the accumulator and returns the accumulator.
2. **flatMap**: This test case uses the `flatMap()` method, which is equivalent to `map()` followed by `flat()`. It iterates over the array and creates a new array with each element.
3. **mapFilter**: This test case uses the `map()` method followed by filtering using `filter()`. It iterates over the array, maps each element, and then filters out any non- truthy values.

**Library Usage**

None of the test cases use any external libraries.

**Special JS Features or Syntax**

There is no mention of any special JavaScript features or syntax in the benchmark definition. However, it's worth noting that `flatMap()` was introduced in ECMAScript 2019 (ES10) and provides a more concise way to perform mapping and flattening operations.

**Options Compared**

The three test cases compare different approaches to achieve similar results:

* **Reduce Push**: Uses the `reduce()` method with a custom callback function.
* **flatMap**: Uses the `flatMap()` method, which is equivalent to `map()` followed by `flat()`.
* **mapFilter**: Uses the `map()` method followed by filtering using `filter()`.

**Pros and Cons of Each Approach**

Here's a brief overview of the pros and cons of each approach:

1. **Reduce Push**:
	* Pros: Can be more concise and efficient for certain use cases.
	* Cons: May require more memory allocation and deallocation due to the custom callback function.
2. **flatMap**:
	* Pros: More concise and readable than using `map()` followed by `flat()`.
	* Cons: May have performance overhead due to the additional method call.
3. **mapFilter**:
	* Pros: Can be more efficient than using `reduce()` with a custom callback function, as it avoids memory allocation issues.
	* Cons: May require more code and be less concise than using `flatMap()`.

**Other Alternatives**

If you wanted to modify the benchmark to compare additional approaches, here are some alternative methods that could be included:

1. Using `forEach()` instead of `map()`
2. Using a for loop instead of `map()` or `reduce()`
3. Using a custom implementation of the mapping and filtering operations
4. Using parallel processing or concurrency to speed up the testing

Keep in mind that adding new test cases may require additional modifications to the benchmark definition JSON and the individual test cases.

Related benchmarks:

Reduce Push vs. flatMap vs 123 (version: 0)

Comparing performance of: Reduce Push vs flatMap vs mapFilter

Created: one year ago by: Guest

Jump to the latest result

Reduce Push

flatMap

mapFilter

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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