Benchmark: new Array using spreading operator vs Array.slice()

Tests:

Array.slice()
var params = [ 1, 2, 3, 5, 8, 13, 21, 34 ]; var other = params.slice();
spreading operator [...array]
var params = [ 1, 2, 3, 5, 8, 13, 21, 34 ]; var other = [...params];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.slice()
spreading operator [...array]

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; rv:112.0) Gecko/20100101 Firefox/112.0

Browser/OS: Firefox 112 on Windows

View result in a separate tab

Test name	Executions per second
Array.slice()	13003736.0 Ops/sec
spreading operator [...array]	6952852.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark.

**What is tested?**

The benchmark compares two approaches to create an array: using the `Array.slice()` method and the spreading operator (`...array`).

**Options compared:**

1. **`Array.slice()`**: This method returns a shallow copy of a portion of an array. It creates a new array object with the specified elements, without modifying the original array.
2. **Spreading operator (`...array`)**: This syntax creates a new array by iterating over the elements of the original array and adding them to a new array.

**Pros and Cons:**

1. **`Array.slice()`**:
	* Pros:
		+ More efficient for large arrays, as it avoids creating a new array object.
		+ Can be faster for complex array operations that require indexing or filtering.
	* Cons:
		+ Creates a shallow copy of the original array, which can lead to unexpected behavior if the original array is modified later.
2. **Spreading operator (`...array`)**:
	* Pros:
		+ Creates a new array with the specified elements, without modifying the original array.
		+ Can be more readable and intuitive for simple array operations.
	* Cons:
		+ May be slower than `Array.slice()` for large arrays due to the overhead of creating a new array object.
		+ Can lead to unexpected behavior if the spread operator is used with objects or other data types.

**Library and syntax:**

The benchmark uses JavaScript's built-in `Array` class, which is part of the ECMAScript standard. The spreading operator (`...array`) was introduced in ECMAScript 2015 (ES6) as a way to create new arrays from existing ones.

**Special JS feature or syntax:**

None mentioned in this specific benchmark.

**Other alternatives:**

For creating an array, you can also use:

* `Array.from()`: Creates a new array from an iterable object (e.g., an array, string, or set).
* `concat()`: Concatenates one or more arrays into a single array.
* `push()`, `unshift()`, and other methods for modifying the end of an array.

However, in this specific benchmark, the only alternatives being compared are `Array.slice()` and the spreading operator (`...array`).

Related benchmarks:

new Array using spreading operator vs Array.slice() (version: 0)

Comparing performance of: Array.slice() vs spreading operator [...array]

Created: one year ago by: Guest

Jump to the latest result

Array.slice()

spreading operator [...array]

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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