Benchmark: Array Flatten -> Reduce+Concat | Reduce+Spread | Loop+Push| Loop+Push+Spread

Script Preparation code:

var params = [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ], [ 7, 8 ], [ 9, 0 ] ];

var flattenReduceConcat = (inputs) => inputs.reduce((acc, input) => acc.concat(input), []);
var flattenReduceSpread = (inputs) => inputs.reduce((acc, input) => [...acc, ...input], []);
var flattenLoopPush = (inputs) => {
  var acc = [];
  for (var i = 0, L = inputs.length; i < L; i++) {
    var input = inputs[i];
    for (var j = 0, l = input.length; j < l; j++) {
      acc.push(input[j]);
    }
  }
  return acc;
}
var flattenLoopPushSpread = (inputs) => {
  var acc = [];
  for (var i = 0, l = inputs.length; i < l; i++) {
    acc.push(...inputs[i]);
  }
  return acc;
}
var flattenLoopSpread = (inputs) => {
  var acc = [];
  for (var i = 0, l = inputs.length; i < l; i++) {
    acc = [...acc, ...inputs[i]];
  }
  return acc;
}

Tests:

Reduce+Concat
var result = flattenReduceConcat(params);
Reduce+Spread
var result = flattenReduceSpread(params);
Loop+Push
var result = flattenLoopPush(params);
Loop+Push+Spread
var result = flattenLoopPushSpread(params);
Loop+Spread
var result = flattenLoopSpread(params);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Reduce+Concat
Reduce+Spread
Loop+Push
Loop+Push+Spread
Loop+Spread

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Overview**

The benchmark measures how fast different approaches can flatten an array of arrays into a single one-dimensional array.

**Approaches Compared**

There are four approaches compared:

1. **Reduce+Concat**: uses `reduce()` with `concat()`
2. **Reduce+Spread**: uses `reduce()` with `spread operator` (`...`)
3. **Loop+Push**: uses a loop to push elements into an accumulator array
4. **Loop+Push+Spread** and **Loop+Spread** are variations of the previous two approaches

**Pros and Cons**

Here's a brief summary:

* **Reduce+Concat**: efficient, but can lead to performance issues due to repeated concatenations. Pros: simple, widely supported. Cons: may be slower than other approaches.
* **Reduce+Spread**: more efficient than Reduce+Concat, as it avoids repeated concatenations. However, the spread operator is relatively new and may not be supported in older browsers. Pros: faster, concise. Cons: may require newer browsers or polyfills.
* **Loop+Push**: straightforward and easy to understand. However, it can lead to performance issues due to repeated push operations. Pros: simple, easy to implement. Cons: slower than other approaches.
* **Loop+Push+Spread** and **Loop+Spread**: variations of the previous two approaches that aim to improve performance by using spread operator instead of push.

**Library Used**

None explicitly mentioned in the benchmark definition or individual test cases. However, some of these approaches may rely on built-in JavaScript methods or libraries like `reduce()`.

**Special JS Feature/Syntax**

The use of the spread operator (`...`) in **Reduce+Spread** and **Loop+Push+Spread** is a modern JavaScript feature introduced in ECMAScript 2018 (ES9). While most modern browsers support it, it may not be supported in older browsers or environments.

**Alternatives**

Other approaches to flatten arrays of arrays could include:

* Using `Array.prototype.flat()` with optional arguments (introduced in ES7)
* Implementing a custom flattening function using recursive techniques
* Utilizing libraries like Lodash or Ramda for array manipulation

The benchmark's focus on comparing existing approaches highlights the importance of understanding performance considerations when writing efficient JavaScript code.

Latest run results:

Run details: (Test run date: 6 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36

Browser/OS: Chrome 69 on Mac OS X 10.14.0

View result in a separate tab

Test name	Executions per second
Reduce+Concat	694926.1 Ops/sec
Reduce+Spread	1883224.6 Ops/sec
Loop+Push	4069430.5 Ops/sec
Loop+Push+Spread	2978232.0 Ops/sec
Loop+Spread	1685309.9 Ops/sec

Related benchmarks:

Array Flatten -> Reduce+Concat | Reduce+Spread | Loop+Push| Loop+Push+Spread | Loop+Spread (version: 0)

Comparing performance of: Reduce+Concat vs Reduce+Spread vs Loop+Push vs Loop+Push+Spread vs Loop+Spread

Created: 6 years ago by: Guest

Jump to the latest result

Reduce+Concat

Reduce+Spread

Loop+Push

Loop+Push+Spread

Loop+Spread

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):