Benchmark: Array.prototype.concat vs spread operator

Tests:

Array.prototype.push.apply(arr, params)
var arr = [ 1, 2, "world" ]; var params = [ "hello", true, 7 ]; Array.prototype.push.apply(arr, params);
arr.push(...params)
var arr = [ 1, 2, "world" ]; var params = [ "hello", true, 7 ]; params.push(...arr);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.push.apply(arr, params)
arr.push(...params)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested.

**Benchmark Definition**

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 the execution time of two different methods to concatenate an array `arr` with another array `params`. The options are:

a. Using `Array.prototype.push.apply(arr, params)`: This method uses the `apply()` method to apply the `push()` method to `arr`, passing `params` as the argument.

b. Using the spread operator (`...`) with `arr.push(...params)`: This method uses the spread operator to create a new array by spreading `params` and then pushes the resulting array into `arr`.

**Pros and Cons**

1. **`Array.prototype.concat()`**:
	* Pros: Well-supported, widely implemented.
	* Cons: Creates a new array, which can be inefficient for large arrays.
2. **The ES6 spread operator (`...`) with `arr.push(...params)`**:
	* Pros: Efficient, creates an in-place modification, and is widely supported.
	* Cons: Requires JavaScript 5+ (ES6) support.

**Other Considerations**

* The benchmark does not account for array size variations. If the array sizes are different between the two methods, this could affect performance.
* The benchmark assumes that `params` is a large array. In practice, if `params` is small or empty, one of the methods might be faster.

**Library Usage**

None of the provided benchmark test cases use any external libraries beyond the built-in JavaScript functions.

**Special JS Feature/Syntax**

The ES6 spread operator (`...`) is used in the second test case. This feature was introduced in ECMAScript 2015 (ES6) and allows for more concise array creation and modification.

**Other Alternatives**

If you want to compare other methods for array concatenation, consider using:

* `Array.prototype.concat()`
* `Array.prototype.push()`, multiple times
* `Array.prototype.unshift()`
* A library function like Lodash's `concat()` or a custom implementation

Latest run results:

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

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

Browser/OS: Chrome 62 on Windows

View result in a separate tab

Test name	Executions per second
Array.prototype.push.apply(arr, params)	2894612.0 Ops/sec
arr.push(...params)	13865515.0 Ops/sec

Related benchmarks:

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

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

Comparing performance of: Array.prototype.push.apply(arr, params) vs arr.push(...params)

Created: 6 years ago by: Guest

Jump to the latest result

Array.prototype.push.apply(arr, params)

arr.push(...params)

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