Benchmark: Array.from() vs spread []

Tests:

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

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

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days 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.

Latest run results:

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

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

Browser/OS: Chrome 120 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
new Array()	12193905.0 Ops/sec
spread	186223104.0 Ops/sec

Related benchmarks:

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

Testing the difference between creating filled arrays.

Comparing performance of: new Array() vs spread

Created: 2 years ago by: Guest

Jump to the latest result

new Array()

spread

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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