Benchmark: new Array(n) vs []

Tests:

new Array(N)
const arr1 = new Array(1000000) for(let i = 0; i < 1000000; i++) { arr1.push({"obj": i}) }
[]
const arr2 = [] for(let i = 0; i < 1000000; i++) { arr2.push({"obj": i}) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new Array(N)
[]

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 116 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
new Array(N)	19.6 Ops/sec
[]	88.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and benchmark preparation code to understand what is being tested, compared, and analyzed.

**Benchmark Definition**

The `Benchmark Definition` json defines two test cases:

1. "new Array(n) vs []": This benchmark compares the efficiency of creating an array using the `new Array(n)` method versus using an empty array literal (`[]`).
2. The script preparation code is not provided, but it's expected to initialize a variable `n` with a large value (in this case, 1000000) before running the test cases.

**Test Cases**

There are two individual test cases:

1. "new Array(N)"
This test case uses the `new Array(n)` method to create an array and then pushes 1 million objects into it using a loop.
```javascript
const arr1 = new Array(1000000)
for (let i = 0; i < 1000000; i++) {
  arr1.push({ "obj": i })
}
```
2. "[]"
This test case uses an empty array literal (`[]`) to create an array and then pushes 1 million objects into it using a loop.
```javascript
const arr2 = []
for (let i = 0; i < 1000000; i++) {
  arr2.push({ "obj": i })
}
```
**Library Usage**

There is no explicit library usage in these test cases, but the `push()` method is used, which is a built-in JavaScript method.

**Special JS Features/Syntax**

Neither of the test cases uses any special JavaScript features or syntax. They are basic examples of creating an array and pushing elements into it using a loop.

**Other Alternatives**

To create an array in JavaScript, there are other alternatives:

1. `Array.from()`: Creates a new array from an iterable or an array-like object.
```javascript
const arr3 = Array.from({ length: 1000000 }, (_, i) => ({ "obj": i }))
```
2. `Array.prototype.fill()`: Fills a specified number of elements with a value in a given array.
```javascript
const arr4 = new Array(1000000).fill(null)
for (let i = 0; i < 1000000; i++) {
  arr4[i] = { "obj": i }
}
```
3. Using `Map` objects, which can be used to create an array-like object.
```javascript
const map = new Map()
for (let i = 0; i < 1000000; i++) {
  map.set(i, { "obj": i })
}

// Convert the map to an array
const arr5 = Array.from(map.values())
```
These alternatives might have different performance characteristics and use cases compared to the `new Array(n)` method and the empty array literal (`[]`).

Related benchmarks:

new Array(n) vs [] (version: 0)

I want to see which one is more efficient

Comparing performance of: new Array(N) vs []

Created: one year ago by: Guest

Jump to the latest result

new Array(N)

[]

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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