Benchmark: Array.prototype.concat vs spread operator vs push 2

Tests:

Array.prototype.concat
var params = [ "hello", true, 7 ]; var other = [ 1, 2 ].concat(params);
spread operator
var params = [ "hello", true, 7 ] var other = [ 1, 2, ...params ]
Push
var params = [ "hello", true, 7 ]; params.push(1); params.push(2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.concat
spread operator
Push

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The test compares three different ways to concatenate arrays in JavaScript:

1. `Array.prototype.concat()`
2. The spread operator (`...`)
3. The `push()` method with multiple assignments

**Options Compared**

Here are the options being compared, along with a brief description of each:

### 1. `Array.prototype.concat()`

* Syntax: `arr.concat(other)`
* Purpose: Concatenates two arrays and returns a new array.
* Pros:
	+ Widely supported across browsers.
	+ Can be used to concatenate multiple arrays at once.
* Cons:
	+ Creates a new array object, which can lead to performance issues for large datasets.
	+ Not as concise as other options.

### 2. The Spread Operator (`...`)

* Syntax: `[ ...arr ]`
* Purpose: Creates a new array by spreading the elements of another array.
* Pros:
	+ Very concise and readable.
	+ Does not create a new array object, making it more efficient than `concat()`.
* Cons:
	+ Not supported in older browsers (pre-ES6).
	+ Can lead to performance issues if used with large datasets.

### 3. The `push()` method with multiple assignments

* Syntax: `arr.push(...other)`
* Purpose: Appends new elements to an array and returns the updated length of the array.
* Pros:
	+ Very concise and readable.
	+ Does not create a new array object, making it more efficient than `concat()`.
* Cons:
	+ Not as widely supported across browsers (Chrome 73+).
	+ Can lead to performance issues if used with large datasets.

**Library and Special JS Features**

In this benchmark, the library being used is none. However, the spread operator (`...`) is a relatively new JavaScript feature introduced in ES6.

**Benchmark Preparation Code and HTML Preparation Code**

The provided JSON does not contain any preparation code for the test. It's likely that the preparation code is already set up by MeasureThat.net or another tool used to run this benchmark.

**Other Alternatives**

If you're looking for alternatives to these options, here are a few:

* `Array.prototype.slice()`: A more traditional way of concatenating arrays, which creates a new array object.
* `Set.concat()` or `Set.from([...])`: For combining sets instead of arrays.
* Library functions like Lodash's `_.concat()` or `_.union()` for more complex data manipulation.

Keep in mind that these alternatives may not be as efficient or concise as the options being compared in this benchmark.

Latest run results:

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

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

Browser/OS: Chrome 73 on Windows 8.1

View result in a separate tab

Test name	Executions per second
Array.prototype.concat	4744335.5 Ops/sec
spread operator	24531764.0 Ops/sec
Push	27863078.0 Ops/sec

Related benchmarks:

Array.prototype.concat vs spread operator vs push 2 (version: 0)

Compare the new ES6 spread operator with the traditional concat() method and push

Comparing performance of: Array.prototype.concat vs spread operator vs Push

Created: 5 years ago by: Guest

Jump to the latest result

Array.prototype.concat

spread operator

Push

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):