Benchmark: flatMap() vs filter().map() vs reduce() ONE FILTER

Script Preparation code:

var arr = [];
var i = 0;

while (i <= 1E5) arr[i] = i++;

Tests:

filter().map()
arr.filter(x => x % 12).map(x => x/100)
flatMap()
arr.flatMap(x => x % 12 ? x/100 : [])
reduce()
arr.reduce((newArray, x) => { if (x % 12) { newArray.push(x / 100) } return newArray }, [])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
filter().map()
flatMap()
reduce()

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 12; SAMSUNG SM-G991N) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/18.0 Chrome/99.0.4844.88 Mobile Safari/537.36

Browser/OS: Chrome Mobile 99 on Android

View result in a separate tab

Test name	Executions per second
filter().map()	35.1 Ops/sec
flatMap()	27.9 Ops/sec
reduce()	136.1 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

**Overview**

The provided JSON represents a JavaScript benchmark test case on the website MeasureThat.net. The test aims to compare the performance of three different methods: `flatMap()`, `filter().map()`, and `reduce()`.

**Benchmark Definition**

The benchmark definition is a string that describes the purpose of the test. In this case, it's comparing the performance of one filtering operation (`flatMap`) against two alternative approaches: `filter().map()` and `reduce()`. The test is specifically designed to compare the execution time of these three methods when applied to an array.

**Options Compared**

The options compared in this benchmark are:

1. **flatMap()**: A method that flattens a nested array into a one-dimensional array.
2. **filter().map()**: A two-step approach that first filters out elements from the original array and then maps over the remaining elements.
3. **reduce()**: A method that reduces an array to a single value by accumulating the results of applying a function to each element.

**Pros and Cons**

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

1. **flatMap()**:
	* Pros: More concise and expressive than `filter().map()` or `reduce()`.
	* Cons: May not be as intuitive for developers who are not familiar with array flattening.
2. **filter().map()**:
	* Pros: Well-established and widely supported in modern browsers.
	* Cons: May incur additional overhead due to the two-step approach.
3. **reduce()**:
	* Pros: Can be more efficient than `filter().map()` when dealing with large datasets.
	* Cons: Requires a good understanding of accumulator functions and may not be as readable for some developers.

**Library Usage**

The test case uses no external libraries, but it does rely on the built-in JavaScript array methods mentioned above.

**Special JS Feature or Syntax**

There are no special features or syntax used in this benchmark that would require additional explanation. The focus is on comparing the performance of three standard array methods.

**Other Considerations**

When interpreting the benchmark results, consider the following:

* **Device platform**: The test was run on a Chrome Mobile 99 browser on an Android device (Samsung SM-G991N).
* **Browser version**: The latest browser version available at the time of testing.
* **Number of executions per second**: A measure of how many times each method executes in one second.

**Alternatives**

If you're interested in exploring alternative approaches, consider:

1. **Using a library like Lodash**, which provides an implementation of `flatMap()` and other utility functions.
2. **Implementing custom array methods** using vanilla JavaScript or a transpiler like Babel.
3. **Comparing the performance of different engines**, such as V8 (Chrome) versus SpiderMonkey (Firefox).

Keep in mind that the benchmark results may not be directly applicable to your specific use case, and you should always test and optimize for your particular requirements.

Related benchmarks:

flatMap() vs filter().map() vs reduce() ONE FILTER (version: 0)

flatMap vs filter map vs reduce()

Comparing performance of: filter().map() vs flatMap() vs reduce()

Created: 2 years ago by: Guest

Jump to the latest result

filter().map()

flatMap()

reduce()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):