Benchmark: Array.prototype.concat vs spread operator

Script Preparation code:

var arr = Array(100).fill([{n: ''}]);

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.concat
spread operator
array.push

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Overview**

The benchmark compares three ways to concatenate an array in JavaScript: `Array.prototype.concat`, the spread operator (`...`), and modifying the original array using `push`. The test aims to determine which method is the most efficient, considering factors like performance, memory usage, and code readability.

**Options Compared**

1. **`Array.prototype.concat`**: This method creates a new array by copying elements from the original array and adding additional elements.
2. **Spread Operator (`...`)**: This method uses the spread operator to create a new array by copying elements from the original array and spreading them into a new array.
3. **Modifying the Original Array using `push`**: This method modifies the original array in place, appending elements to it.

**Pros and Cons**

1. **`Array.prototype.concat`**:
	* Pros: Wide browser support, easy to read and understand.
	* Cons: Creates a new array, which can lead to increased memory usage and slower performance compared to other methods.
2. **Spread Operator (`...`)**:
	* Pros: More concise and expressive than `concat`, creates a new array with minimal overhead.
	* Cons: Limited browser support (Chrome 81+), may not be as readable for complex cases.
3. **Modifying the Original Array using `push`**:
	* Pros: Most efficient way to modify an existing array, no memory allocation or copying involved.
	* Cons: May not be as readable or maintainable for some developers, can lead to unexpected side effects if not used carefully.

**Library and Special JS Features**

In this benchmark, there are no libraries used. However, the `...` spread operator is a feature introduced in ES6, which allows for more concise and expressive code.

**Test Cases and Considerations**

The test cases cover three scenarios:

1. `Array.prototype.concat`: Tests the performance of concatenating an array using the traditional method.
2. Spread Operator (`...`): Tests the performance of concatenating an array using the spread operator.
3. Modifying the Original Array using `push`: Tests the performance of modifying the original array in place.

When choosing between these methods, consider the trade-offs:

* If you need to concatenate an existing array and don't mind creating a new one, `Array.prototype.concat` is a safe choice.
* For more concise code and good performance, use the spread operator (`...`) if your target browser supports it.
* When working with large datasets or performance-critical code, modifying the original array using `push` may be the most efficient option.

**Alternatives**

Other alternatives to concatenate arrays in JavaScript include:

1. Using a library like Lodash, which provides an optimized implementation of array concatenation.
2. Creating a new array using `Array.from()` and then pushing elements onto it.
3. Using a more functional programming approach with methods like `reduce()` or `map()`.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36

Browser/OS: Chrome 81 on Mac OS X 10.15.4

View result in a separate tab

Test name	Executions per second
Array.prototype.concat	2076648.6 Ops/sec
spread operator	2358425.5 Ops/sec
array.push	3955302.5 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.concat vs spread operator vs array.push

Created: 6 years ago by: Guest

Jump to the latest result

Array.prototype.concat

spread operator

array.push

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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