Benchmark: slice vs spread operator

Tests:

Array.prototype.slice
var params = [ "hello", true, 7 ]; var other = params.slice();
spread operator
var params = [ "hello", true, 7 ] var other = [ ...params ]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.prototype.slice
spread operator

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 84 on Windows

View result in a separate tab

Test name	Executions per second
Array.prototype.slice	121841408.0 Ops/sec
spread operator	76282480.0 Ops/sec

Autogenerated LLM Summary (model llama3.1:latest, generated one month ago):

LLMs can make mistakes. Check important info.

Let's break down what's being tested here.

**Benchmark Description**
The benchmark is comparing two ways to create a copy of an array in JavaScript: using the `slice()` method and using the spread operator (`...`).

**Test Cases**

1. **Array.prototype.slice**: This test case uses the traditional `slice()` method to create a new array from an existing one.
	* Code: `var params = [ "hello", true, 7 ]; var other = params.slice();`
	* Library/Feature: None
	* Description: Simply calls the `slice()` method on the original array `params` to create a new array `other`.
2. **Spread operator**: This test case uses the spread operator (`...`) to create a new array from an existing one.
	* Code: `var params = [ "hello", true, 7 ]; var other = [ ...params ];`
	* Library/Feature: ES6 Spread Operator (introduced in ECMAScript 2015)
	* Description: Uses the spread operator to "spread" the elements of the original array `params` into a new array `other`.

**Benchmark Results**

The latest benchmark results show that on a Chrome 84 browser on Windows, running the `Array.prototype.slice` test case executes at approximately 121.8 million times per second, while the `Spread operator` test case executes at approximately 76.2 million times per second.

**Pros and Cons of each approach**

* **slice() method**: Pros: widely supported by older browsers, simple to use; Cons: might be slower than spread operator in modern browsers.
* **Spread operator**: Pros: concise syntax, potentially faster than slice() in modern browsers; Cons: introduced in ES6, might not work in older browsers or environments without transpilation.

**Other Alternatives**

For creating a copy of an array in JavaScript, other alternatives include:

* Using `concat()` method (not tested here)
* Using a loop to manually create a new array
* Using a library like Lodash's `clone()` function (if needed)

Keep in mind that the actual performance difference between these approaches might vary depending on your specific use case and environment.

Related benchmarks:

slice vs spread operator (version: 0)

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

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

Created: 4 years ago by: Guest

Jump to the latest result

Array.prototype.slice

spread operator

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated one month ago):