Benchmark: Array Spread Operator Performance

Tests:

without spread operator
let prime = Array(10 ** 7).fill(true);
with spread operator
let prime = [...Array(10 ** 7).fill(true)];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
without spread operator
with spread operator

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 12; Redmi Note 9 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 112 on Android

View result in a separate tab

Test name	Executions per second
without spread operator	5.7 Ops/sec
with spread operator	3.2 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 JSON and explain what's being tested.

**Overview**

The benchmark is measuring the performance of creating an array with `fill()` method using two different approaches: without using the spread operator (`...`) and with using the spread operator.

**Options Compared**

Two options are compared:

1. **Without Spread Operator**: `Array(10 ** 7).fill(true);`
	* Pros:
		+ Simple, straightforward syntax.
		+ Easy to understand for most developers.
	* Cons:
		+ May be slower due to the need to create an array and then fill it with values.
2. **With Spread Operator**: `let prime = [...Array(10 ** 7).fill(true)];`
	* Pros:
		+ More concise syntax, which can lead to faster execution times in some cases.
		+ Can be more readable for developers familiar with the spread operator.

**Library and Special Features**

There are no libraries mentioned in this benchmark. However, it's worth noting that the use of spread operator (`...`) is a JavaScript feature introduced in ECMAScript 2015 (ES6). It allows creating new arrays by spreading existing array elements.

**Other Considerations**

When using the spread operator, the browser may be able to optimize it differently than the `fill()` method. This can result in different execution times for the two approaches.

Additionally, some browsers may have special optimizations or cacheing mechanisms that affect the performance of certain methods or features.

**Alternatives**

To measure similar benchmarks, you could compare other array creation methods, such as:

* Using `Array.prototype.fill()`: `let prime = new Array(10 ** 7).fill(true);`
* Using a custom function to create and fill the array: `function createArray(size) { let arr = []; for (let i = 0; i < size; i++) { arr.push(true); } return arr; } let prime = createArray(10 ** 7);`

These alternatives might provide different results due to differences in browser optimizations or execution times.

I hope this explanation helps!

Related benchmarks:

Array Spread Operator Performance (version: 0)

Comparing performance of: without spread operator vs with spread operator

Created: 3 years ago by: Guest

Jump to the latest result

without spread operator

with spread operator

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