Benchmark: Concat vs push(...) vs flat for large arrays of arrays

Script Preparation code:

window.top.tests = {control:[], concat:[], spread:[], flat: []};
window.test = (new Array(10)).fill(null);
window.arrays = (new Array(10)).fill(window.test);
window.cutoff = 5000;

Tests:

Control (for push)
window.top.tests.control = window.arrays.reduce((acc, arr) => { acc.push(...arr); return acc; }, []); if (window.top.tests.control.length > window.cutoff) { window.top.tests.control = []; console.log('reset control'); }
Concat
window.top.tests.concat = window.arrays.reduce((acc, arr) => acc.concat(arr), []); if (window.top.tests.concat.length > window.cutoff) { window.top.tests.concat = []; console.log('reset concat'); }
Spread
window.top.tests.spread = window.arrays.reduce((acc, arr) => [...acc, ...arr], []); if (window.top.tests.spread.length > window.cutoff) { window.top.tests.spread = []; console.log('reset spread'); }
Flat
window.top.tests.flat = window.arrays.flat(); if (window.top.tests.flat.length > window.cutoff) { window.top.tests.flat = []; console.log('reset flat'); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Control (for push)
Concat
Spread
Flat

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
Control (for push)	325906.3 Ops/sec
Concat	192537.9 Ops/sec
Spread	225688.7 Ops/sec
Flat	197115.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 5 months ago):

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net is a platform for comparing the performance of different JavaScript approaches to manipulate arrays. The provided benchmark defines four test cases: `Control (for push)`, `Concat`, `Spread`, and `Flat`. These tests measure how fast each approach can append elements to an array.

**Test Cases and Approaches**

1. **Control (for push)**:
	* Approach: Using the `push()` method, which appends one or more elements to the end of an array.
	* Example Benchmark Definition: `window.top.tests.control = window.arrays.reduce((acc, arr) => {\r\n  acc.push(...arr);\r\n  return acc;\r\n}, []);`
2. **Concat**:
	* Approach: Using the `concat()` method, which returns a new array that is the result of concatenating an array with another array or value.
	* Example Benchmark Definition: `window.top.tests.concat = window.arrays.reduce((acc, arr) => acc.concat(arr), []);`
3. **Spread**:
	* Approach: Using the spread operator (`...`) to expand an array into its individual elements and then reassigning them to a new array.
	* Example Benchmark Definition: `window.top.tests.spread = window.arrays.reduce((acc, arr) => [...acc, ...arr], []);`
4. **Flat**:
	* Approach: Using the `flat()` method, which returns an array with all sub-array elements concatenated into it recursively up to a specified depth.
	* Example Benchmark Definition: `window.top.tests.flat = window.arrays.flat();`

**Pros and Cons**

Each approach has its strengths and weaknesses:

* **Control (for push)**:
	+ Pros: Simple and efficient, as it only requires pushing elements onto the array.
	+ Cons: Can be slower for large arrays due to the overhead of repeatedly calling `push()`.
* **Concat**:
	+ Pros: Creates a new array, which can avoid modifying the original array.
	+ Cons: Requires creating an intermediate array and copying its contents, which can be slow for large arrays.
* **Spread**:
	+ Pros: Avoids modifying the original array and uses the spread operator, which is efficient.
	+ Cons: Can be slower than `push()` due to the overhead of expanding the array using the spread operator.
* **Flat**:
	+ Pros: Recursively flattens the array, avoiding the need for explicit looping or concatenation.
	+ Cons: Can be slower due to the recursive nature of `flat()`.

**Library and Special JS Features**

The benchmark uses the following libraries:

* No external libraries are used in this benchmark.
* The `reduce()` method is used, which is a built-in JavaScript array method that applies a function to each element in an array.

No special JS features are mentioned in the benchmark definition.

Related benchmarks:

Concat vs push(...) vs flat for large arrays of arrays (version: 0)

Comparing the various ways to append to a large array

Comparing performance of: Control (for push) vs Concat vs Spread vs Flat

Created: 4 years ago by: Guest

Jump to the latest result

Control (for push)

Concat

Spread

Flat

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 5 months ago):