Benchmark: Flatten array - MeasureThat.net

Script Preparation code:

var arr = Array(10_0).fill(Array(10).fill(Array(10).fill(0)))
function flattenReducer(arr) {
    return arr.reduce((acc, cur) => acc.concat(Array.isArray(cur) ? flattenReducer(cur) : cur), []);
};
function* flattenGenerator(arr)
{
    for (const val of arr) {
        Array.isArray(val) ? yield* flattenGenerator(val) : yield val;
    }
}
function recursiveFlatten(arr) {
    const result = [];
    arr.forEach(item => {
        if (Array.isArray(item)) {
            result.push(...recursiveFlatten(item));
        }
        else {
            result.push(item);
        }
    });
    return result;
};

Tests:

Using reducer
flattenReducer(arr)
Using generators
[...flattenGenerator(arr)]
Recursive push flatten
recursiveFlatten(arr)
Using array flat
arr.flat(Infinity)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Using reducer
Using generators
Recursive push flatten
Using array flat

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.3 Safari/605.1.15

Browser/OS: Safari 15 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Using reducer	541.8 Ops/sec
Using generators	444.2 Ops/sec
Recursive push flatten	847.5 Ops/sec
Using array flat	15166.7 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 world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition JSON**

The provided Benchmark Definition JSON represents a single benchmark for flattening an array in JavaScript. The script preparation code includes three different approaches:

1. `flattenReducer(arr)`: Uses the `reduce()` method with a custom reducer function to flatten the array.
2. `flattenGenerator(arr)`: Uses a generator function (`*` denotes that it's a generator function, not a regular function) to flatten the array.
3. `recursiveFlatten(arr)`: A recursive function that pushes each item from the array into a result array.

The script preparation code is written in JavaScript, using modern syntax and features like arrow functions (`=>`) and template literals (`\r\n` is used for line breaks).

**Options Compared**

In this benchmark, four different approaches are compared:

1. `flattenReducer(arr)`: Uses the `reduce()` method.
2. `flattenGenerator(arr)`: Uses a generator function.
3. `recursiveFlatten(arr)`: A recursive function that pushes each item into a result array.
4. `arr.flat(Infinity)`: Uses the built-in `flat()` method with an infinite depth.

**Pros and Cons of Each Approach**

Here's a brief overview of each approach:

1. **`flattenReducer(arr)`**: Pros: Easy to implement, efficient use of memory (only creates one result array). Cons: May not be as performant as other methods due to the overhead of `reduce()`.
2. **`flattenGenerator(arr)`**: Pros: Can be more performant than recursive functions, allows for asynchronous iteration. Cons: Requires a good understanding of generators and may have additional memory usage.
3. **`recursiveFlatten(arr)`**: Pros: Simple to understand, easy to implement. Cons: May be slower due to the overhead of recursive function calls, can cause stack overflow for large inputs.
4. **`arr.flat(Infinity)`**: Pros: Built-in method, efficient use of memory (only creates one result array). Cons: May not work well with nested arrays of varying depths, can lead to performance issues if `Infinity` is used.

**Library and Special JS Features**

In this benchmark, there are no libraries or special JavaScript features being tested. The script preparation code only uses built-in JavaScript features and syntax.

**Other Considerations**

When comparing these approaches, it's essential to consider factors like:

* Memory usage: How much memory does each approach use?
* Performance: Which approach is faster?
* Scalability: How well do each approaches handle large inputs?

**Alternatives**

Some alternative approaches that could be included in a benchmark for flattening an array include:

1. `for` loop: A simple iterative approach using a `for` loop.
2. `Array.prototype.forEach()`: Using the `forEach()` method to iterate over the array and push each item into a result array.
3. `Array.prototype.map()`: Using the `map()` method to create a new array with flattened elements.

These alternatives can provide additional insights into different approaches and help identify which one is most efficient in various scenarios.

Related benchmarks:

Flatten array (version: 0)

Comparing performance of: Using reducer vs Using generators vs Recursive push flatten vs Using array flat

Created: 2 years ago by: Guest

Jump to the latest result

Using reducer

Using generators

Recursive push flatten

Using array flat

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