Benchmark: Array.prototype.concat vs spread operator (jquery removed)

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 ]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.concat
spread operator

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to help explain the provided JavaScript microbenchmark.

**Benchmark Overview**

The benchmark compares two approaches for concatenating arrays in JavaScript:

1. `Array.prototype.concat()`
2. The new ES6 spread operator (`...`)

**Options Compared**

The benchmark tests both options with a specific dataset: an array of three elements, including a string, a boolean, and an integer.

**Pros and Cons of Each Approach**

* **`Array.prototype.concat()`**:
	+ Pros: widely supported, well-established method.
	+ Cons: can be slower due to the creation of a new array object.
* **ES6 Spread Operator (`...`)**:
	+ Pros: modern, efficient, and concise way to concatenate arrays.
	+ Cons: requires JavaScript version support (not available in older browsers).

**Library Usage**

There is no external library used in this benchmark.

**Special JS Feature/Syntax**

The spread operator (`...`) was introduced in ES6 and is a relatively new feature in JavaScript. It allows for the creation of new arrays from existing ones by specifying the elements to be included.

**Benchmark Preparation Code**

Not provided, as it's assumed that the test cases are self-contained and don't require any external setup or dependencies.

**Other Alternatives**

In addition to `Array.prototype.concat()` and the ES6 spread operator, other methods for concatenating arrays in JavaScript include:

* Using the `push()` method: `array.push(...new_array)`
* Using the `slice()` method with a negative offset: `array.slice(-new_array.length)`

While these alternatives may be available, they are not typically used in production code due to performance considerations.

**Benchmark Results**

The latest benchmark results show that the ES6 spread operator (`...`) is generally faster than `Array.prototype.concat()`, but this may vary depending on specific use cases and browser versions. The results demonstrate the benefits of using modern JavaScript features for performance-critical code paths.

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 12; RMX3363) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.5112.102 Mobile Safari/537.36 EdgA/104.0.1293.70

Browser/OS: Chrome Mobile 104 on Android

View result in a separate tab

Test name	Executions per second
Array.prototype.concat	4235969.5 Ops/sec
spread operator	26365348.0 Ops/sec

Related benchmarks:

Array.prototype.concat vs spread operator (jquery removed) (version: 0)

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

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

Created: 2 years ago by: Guest

Jump to the latest result

Array.prototype.concat

spread operator

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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