Benchmark: Array.from() vs spread []

Tests:

new Array()
new Array(0, 1, 2)
spread
[0, 1, 2]

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

spread

163.5M/s

new Array()

107.5M/s

Fastest: spread (1.5x faster)

View exact numbers

✓ spread: 163,538,800 ops/sec
• new Array(): 107,489,464 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new Array()
spread

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

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

Browser/OS: Chrome 147 on Windows

View result in a separate tab

spread

29.7M/s

new Array()

10.4M/s

View exact numbers

Test name	Executions per second
✓ spread	29,676,416 Ops/sec
new Array()	10,447,842 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark is defined by two different approaches to create filled arrays:

1. `new Array(0, 1, 2)`
2. `[0, 1, 2]`

These two approaches are compared to measure their performance differences.

**Options Compared**

The two options being compared are:

* Using the constructor syntax (`new Array(0, 1, 2)`) to create a filled array.
* Using the spread operator (`[0, 1, 2]`) to create a filled array.

**Pros and Cons of Each Approach**

**Constructor Syntax (New Array)**

Pros:

* Can be more readable and expressive, especially for larger arrays.
* Allows for more control over the initialization process (e.g., initializing elements with default values).

Cons:

* May incur additional overhead due to the constructor's creation process.

**Spread Operator ([0, 1, 2])**

Pros:

* Is concise and easy to read.
* Does not incur the same overhead as the constructor syntax.

Cons:

* Less readable than the constructor syntax for larger arrays.
* Limited control over initialization processes (e.g., default values).

**Library Used: None**

There is no library used in this benchmark. Both approaches are built-in JavaScript constructs.

**Special JS Feature/Syntax:**

No special JavaScript features or syntax are mentioned in the provided JSON.

**Other Alternatives**

Some alternative approaches to create filled arrays could be:

* Using `Array.from()` with an array of initial values (e.g., `[...new Array(3)].map((_, i) => i)`).
* Using a loop to initialize elements (e.g., `let arr = []; for (let i = 0; i < 3; i++) { arr.push(i); }`).

These alternatives might offer performance advantages or more readable code, but they are not explicitly tested in this benchmark.

Overall, the benchmark provides a simple comparison between two common approaches to create filled arrays in JavaScript, highlighting their pros and cons.

Array.from() vs spread [] (version: 0)

Testing the difference between creating filled arrays.

Comparing performance of: `new Array() vs spread`

Created: 4 years ago by: Guest

Go to the latest result

new Array()

spread

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Array.from() vs spread [] (version: 0)

Testing the difference between creating filled arrays.

Comparing performance of: new Array() vs spread

Created: 4 years ago by: Guest

Go to the latest result

new Array()

spread

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `new Array() vs spread`