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

Script Preparation code:

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

Tests:

filter().map()
var results1 = [] arr.filter(x => x % 3).map(x => x/100)
flatMap()
var results2 = [] arr.flatMap(x => x % 3 ? x/100 : [])
forEach()
var results3 = [] arr.forEach(x => { if (x % 3) { results3.push(x / 100) } })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

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 benchmark and explore what's being tested.

**Benchmark Definition**

The benchmark is testing three different approaches to perform operations on an array: `forEach()`, `filter().map()`, and `flatMap()`.

**Options Compared**

Here's a brief overview of each option:

1. **forEach()**: The `forEach` method executes a function for each element in the array, without returning any value. In this benchmark, it pushes elements to an array if they meet a certain condition.
2. **filter().map()**: This approach uses the `filter()` method to remove elements from the array that don't meet the condition, and then applies the `map` function to each remaining element, applying another transformation.
3. **flatMap()**: The `flatMap` method is similar to `filter()`, but instead of creating a new array with the transformed elements, it returns an iterator with the same elements.

**Pros and Cons**

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

1. **forEach()**:
	* Pros: simple, efficient (no extra memory allocation), easy to read.
	* Cons: can lead to performance issues if not optimized correctly (e.g., pushing to an array).
2. **filter().map()**:
	* Pros: more expressive and intuitive than `forEach`, avoids unnecessary memory allocation.
	* Cons: potentially slower due to the extra function call, may incur overhead from creating a new array.
3. **flatMap()**:
	* Pros: optimized for this specific use case, can reduce memory allocation overhead.
	* Cons: requires understanding of the iterator API, may be less intuitive than `filter().map()`.

**Library and Special JS Features**

There are no libraries used in this benchmark. However, it's worth noting that JavaScript has some special features, such as:

* **Arrow functions**: Used in the `forEach` method definition.
* **Template literals**: Used to define the script preparation code (e.g., `var i = 0; var arr = [];\r\n...`).

Related benchmarks:

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

flatMap vs filter map

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

Created: 4 years ago by: Guest

Jump to the latest result

filter().map()

flatMap()

forEach()

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