Benchmark: flatMap() with const vs filter()x1.map() vs reduce()

Script Preparation code:

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

Tests:

filter().map()
arr.filter(x => x % 12 && x % 5 && x % 3).map(x => x/100)
flatMap()
arr.flatMap(x => x % 12 && x % 5 && x % 3 ? x/100 : e)
reduce()
arr.reduce((newArray, x) => { if (x % 12 && x % 5 && x % 3) { 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:

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.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The benchmark is designed to compare three different approaches for filtering and transforming an array in JavaScript:

1. `filter()` followed by `map()`
2. `flatMap()`
3. `reduce()`

These three functions are all part of the modern JavaScript API, introduced in ECMAScript 2019.

**Options being compared**

The benchmark is comparing the performance of each approach with a specific filter condition: `(x % 12 && x % 5 && x % 3)`. This means that only elements in the array that satisfy this condition will be transformed and added to the output array.

**Pros and Cons of each approach**

1. `filter()` followed by `map()`:
	* Pros:
		+ Well-established and widely supported
		+ Easy to understand and implement
	* Cons:
		+ Requires two function calls, which can be slower than a single call
		+ May create intermediate arrays, which can lead to memory allocation overhead
2. `flatMap()`:
	* Pros:
		+ Single function call, which can be faster than two separate calls
		+ Reduces memory allocation overhead by combining the filtering and mapping steps
	* Cons:
		+ Less widely supported than `filter()` and `map()`
		+ May not be as efficient for very large datasets due to its internal implementation details
3. `reduce()`:
	* Pros:
		+ Single function call, which can be faster than two separate calls
		+ Can accumulate results in a single array, reducing memory allocation overhead
	* Cons:
		+ Less intuitive and less widely supported than `filter()` and `map()`
		+ Requires more explicit handling of initial values and accumulator updates

**Library usage**

There are no libraries used in this benchmark.

**Special JavaScript features or syntax**

None mentioned.

**Other considerations**

* The benchmark is running on a Windows 10 desktop with Firefox 110, which may not be representative of all possible environments.
* The `while` loop used to create the input array is not the most efficient way to generate data. A more modern approach would use `Array.from()` or `Array(100000)`.
* The benchmark only runs three test cases, which may not provide a comprehensive picture of the performance characteristics of each approach.

**Alternatives**

If you're interested in exploring alternative approaches for filtering and transforming arrays, here are some options:

1. Use `Array.prototype.every()` instead of `filter()`: This method returns a boolean value indicating whether all elements in the array pass the test.
2. Use `Array.prototype.some()` instead of `filter()`: This method returns a boolean value indicating whether at least one element in the array passes the test.
3. Use `Array.prototype.forEach()` with a callback function: This method allows you to iterate over the array without creating intermediate arrays.
4. Consider using a different data structure, such as a `Set` or a `Map`, depending on your specific use case.

Keep in mind that these alternatives may have different performance characteristics and trade-offs compared to `filter()`, `flatMap()`, and `reduce()`

Related benchmarks:

flatMap() with const vs filter()x1.map() vs reduce() (version: 0)

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