Benchmark: flatMap() vs filter().map() Bruno 1111

Script Preparation code:

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

Tests:

filter().map()
arr.filter(x => x > 1).map(x => x * 2)
flatMap()
arr.flatMap(x => x <= 1 ? [] : [x*2])

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/111.0

Browser/OS: Firefox 111 on Linux

View result in a separate tab

Test name	Executions per second
filter().map()	475.7 Ops/sec
flatMap()	417.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the benchmark.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark that compares two approaches for flattening an array: `filter().map()` and `flatMap()`. The test case uses a predefined array, `arr`, which is populated with values from 0 to 100,000 using a while loop in the script preparation code.

**Options compared**

The benchmark compares the execution time of:

1. **`filter().map()`**: This approach first filters out elements greater than 1 using `Array.prototype.filter()`, and then maps each remaining element to its double value using `Array.prototype.map()`.
2. **`flatMap()`**: This approach directly flattens the array by applying a transformation function to each element, which in this case is a simple multiplication of the value by 2.

**Pros and Cons**

1. **`filter().map()`**:
	* Pros: More explicit filtering and mapping, can be easier to understand for developers familiar with these methods.
	* Cons: Requires two separate calls to `Array.prototype`, which can lead to slower performance due to function call overhead.
2. **`flatMap()`**:
	* Pros: Single pass through the array, potentially faster execution time since it avoids the function call overhead of `filter()`.
	* Cons: Can be less intuitive for developers unfamiliar with this method.

**Library and purpose**

There is no library used in this benchmark. It's a native JavaScript implementation.

**Special JS feature or syntax**

The test case uses the arrow function syntax (`x => x * 2`) which was introduced in ECMAScript 2015 (ES6). This allows for concise and readable code, but may not be supported by older browsers or environments.

**Other alternatives**

Alternative approaches to flatten an array include:

1. `Array.prototype.forEach()`: While not as efficient as `flatMap()` or `filter().map()`, this method can still achieve the desired result.
2. Using a custom loop: Implementing a manual loop to iterate through the array and append elements to a new array.

In summary, the benchmark compares two approaches for flattening an array: using `filter().map()` (with explicit filtering and mapping) versus `flatMap()` (a single pass with direct transformation). The choice between these approaches depends on personal preference, performance considerations, and compatibility requirements.

Related benchmarks:

flatMap() vs filter().map() Bruno 1111 (version: 0)

flatMap vs filter map

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

Created: one year ago by: Guest

Jump to the latest result

filter().map()

flatMap()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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