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

Script Preparation code:

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

Tests:

filter().map()
arr .filter(x => x !== 0 && x % 2) .map(x => Math.sqrt(Math.pow(x, 2) + Math.pow(x, 2)))
flatMap()
arr .flatMap(x => (x !== 0 && x % 2) ? Math.sqrt(Math.pow(x, 2) + Math.pow(x, 2)) : [])
reduce()
arr .reduce((acc, x) => { if (x !== 0 && x % 2) { acc.push(Math.sqrt(Math.pow(x, 2) + Math.pow(x, 2))) } 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.

Let's break down what is tested in the provided JSON benchmark definition and its implications.

**Benchmark Definition:**
The benchmark compares three different approaches to process an array of numbers:
1. `filter()`.map()`
2. `flatMap()`
3. `reduce()`

**Options Compared:**

*   **Filter()**: Removes elements from the array that don't meet a specified condition (in this case, even numbers).
*   **Map()**: Applies a transformation function to each element in the array.
*   **FlatMap()**: Similar to Map(), but it flattens the resulting array of arrays into a single array.

**Pros and Cons:**

1.  **Filter()**: Can be efficient for small datasets or when you only need a subset of data. However, its performance can degrade quickly as the dataset size increases.
    *   Pros: Efficient for small datasets.
    *   Cons: Performance degrades with large datasets.
2.  **Map()**: Performs operations on each element and returns an array of results. It's useful when you need to transform data in some way, but it can be less efficient than using `flatMap()` because of the extra layer of processing.
    *   Pros: Can be used for transformations, but generally less efficient than flatMap().
    *   Cons: More overhead due to an additional operation on each element.
3.  **FlatMap()**: Flattens arrays of arrays into a single array, which can lead to higher performance compared to `filter().map()` because it avoids the extra processing step of mapping and then flattening.
    *   Pros: Can be more efficient than filter().map(), especially when dealing with large datasets or multiple levels of nesting.
    *   Cons: Requires that all elements in the array are arrays themselves.

**Library and Purpose:**

In this benchmark, `Array.prototype.filter()`, `Array.prototype.map()`, and `Array.prototype.flatMap()` are used. These methods are built-in to JavaScript and belong to the `Array` prototype, meaning they can be called directly on any array object.

These methods have been part of the ECMAScript standard since ES6 (ECMAScript 2015), so most modern browsers should support them.

**Special JS Feature or Syntax:**

There's no special feature or syntax being tested in this benchmark. It focuses solely on evaluating different approaches to process arrays using built-in JavaScript methods.

Related benchmarks:

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

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

Created: 4 years ago by: Registered User

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