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

Script Preparation code:

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

Tests:

filter().map()
arr.filter(x => x % 3).map(x => x/100)
flatMap()
arr.flatMap(x => x % 3 ? x/100 : [])
reduce
arr.reduce((acc, x) => { if (x % 3 === 0) { return acc; } else { acc.push(x / 100); return acc; } }, []);

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:

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 benchmark that compares the performance of three different methods: `flatMap()`, `filter().map()`, and `reduce()`.

**Methods Being Compared**

1. **`flatMap()`**: This method is used to flatten an array of arrays into a single array.
2. **`filter().map()`**: This method uses the `filter()` function to remove elements from the array that don't meet a certain condition, followed by the `map()` function to apply a transformation to each remaining element.
3. **`reduce()`**: This method is used to reduce an array of values into a single value.

**Options Compared**

The benchmark compares the performance of these three methods when applied to different parts of the data:

* In the first test case, both `filter().map()` and `flatMap()` are applied to every element in the array. The `reduce()` method is not used.
* In the second test case, only `filter().map()` is applied to the filtered elements (i.e., those that don't meet the condition). The `flatMap()` and `reduce()` methods are not used.
* In the third test case, both `flatMap()` and `reduce()` are applied. The `filter().map()` method is not used.

**Pros and Cons**

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

1. **`flatMap()`**: This method can be more efficient than `filter().map()` because it avoids the overhead of creating an intermediate array during filtering.
	* Pros: Can be faster, less memory-intensive
	* Cons: Limited to flattening arrays, may not work well with all data structures
2. **`filter().map()`**: This method is often easier to read and understand than `flatMap()`, but it can be slower due to the overhead of creating an intermediate array.
	* Pros: Easier to read, more flexible, works well with most data structures
	* Cons: Can be slower, creates an intermediate array
3. **`reduce()`**: This method is often used for aggregating or reducing arrays, but it may not be the best choice for this specific benchmark.
	* Pros: Works well for aggregation, can be more memory-efficient than `filter().map()`
	* Cons: May not be suitable for flattening arrays, can be slower due to accumulation

**Library Used**

None of the methods in this benchmark use a library.

**Special JavaScript Features or Syntax**

There are no special JavaScript features or syntax used in this benchmark. However, it's worth noting that the `flatMap()` method was introduced in ECMAScript 2019 (ES10) and may not be supported by older browsers or versions of JavaScript.

**Alternatives**

If you need to flatten arrays, other methods you could consider include:

* Using `Array.prototype.flat()` (introduced in ECMAScript 2019)
* Using a loop with array indexing (`arr[i]`)
* Using a third-party library like Lodash's `flatten` function

If you need to aggregate or reduce arrays, other methods you could consider include:

* Using `Array.prototype.reduce()`
* Using a loop with accumulation
* Using a third-party library like Lodash's `reduceBy` function.

Related benchmarks:

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

flatMap vs filter map

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

Created: 3 years ago by: Guest

Jump to the latest result

filter().map()

flatMap()

reduce

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):