Benchmark: Array 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 ]; var other = [ 1, 2 ].push(params);

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 dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided benchmark compares three approaches for concatenating or pushing an array:

1. `Array.prototype.concat()`
2. The new ES6 spread operator (`...`)
3. `Array.prototype.push()` with an array as its second argument

**Options Compared**

These three options are compared in the following test cases:

* `Array.prototype.concat()`: This method concatenates two arrays and returns a new array.
* Spread operator (`...`): This operator allows you to expand an array by adding elements from another iterable (like an array or a string).
* `Array.prototype.push()` with an array as its second argument: This method adds one or more elements to the end of an array.

**Pros and Cons**

Here's a brief summary of each option:

### Array.prototype.concat()

Pros:

* Well-established method, widely supported.
* Easy to use.

Cons:

* Creates a new array, which can be inefficient for large arrays.
* Can lead to unnecessary memory allocations.

### Spread Operator (`...`)

Pros:

* Creates a shallow copy of the original array (not deep).
* More efficient than `concat()` when dealing with large arrays.
* Convenient and modern syntax.

Cons:

* Requires modern JavaScript engines that support the spread operator.
* May not be supported in older browsers or environments.

### Array.prototype.push()

Pros:

* In-place operation, reducing memory allocations.
* Can be more efficient for small to medium-sized arrays.

Cons:

* Requires an array as its second argument, which can lead to confusion.
* Not suitable for large arrays due to performance and memory concerns.

**Library Used**

There is no explicit library mentioned in the benchmark definition or test cases. However, it's worth noting that `Array.prototype.concat()` relies on the internal workings of the JavaScript engine, while the spread operator (`...`) and `Array.prototype.push()` are built-in methods of the JavaScript language.

**Special JS Feature or Syntax**

The spread operator (`...`) is a relatively new addition to the JavaScript language, introduced in ECMAScript 2015 (ES6). It's a convenient way to create arrays or spreads from other iterables. However, it requires modern JavaScript engines that support this syntax.

In contrast, `Array.prototype.concat()` and `Array.prototype.push()` are more established methods with longer histories.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.117 Safari/537.36

Browser/OS: Chrome 79 on Linux

View result in a separate tab

Test name	Executions per second
Array.prototype.concat	5034966.5 Ops/sec
spread operator	17483142.0 Ops/sec
Push	19569080.0 Ops/sec

Related benchmarks:

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