Benchmark: Array constructor vs literal performance - 1000 items

Tests:

Array constructor - 1000 items
var n = 1000; var arr = new Array(n); for (var i = 0; i < n; i++) { arr[i] = i; }
Array literal - 1000 items
var n = 1000; var arr = []; for (var i = 0; i < n; i++) { arr.push(i); }
Array literal (assign by index) - 1000 items
var n = 1000; var arr = []; for (var i = 0; i < n; i++) { arr[i] = i; }
Array literal (explicit length) - 1000 items
var n = 1000; var arr = []; arr.length = n; for (var i = 0; i < n; i++) { arr[i] = i; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array constructor - 1000 items
Array literal - 1000 items
Array literal (assign by index) - 1000 items
Array literal (explicit length) - 1000 items

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; rv:140.0) Gecko/20100101 Firefox/140.0

Browser/OS: Firefox 140 on Mac OS X 10.15

View result in a separate tab

Array literal - 1000 items

576K/s

Array constructor - 1000 items

503K/s

Array literal (explicit length) - 1000 items

457K/s

Array literal (assign by index) - 1000 items

457K/s

View exact numbers

Test name	Executions per second
✓ Array literal - 1000 items	576,286 Ops/sec
Array constructor - 1000 items	502,700 Ops/sec
Array literal (explicit length) - 1000 items	457,338 Ops/sec
Array literal (assign by index) - 1000 items	456,635 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark compares the performance of four ways to create an array in JavaScript: using the `new Array()` constructor, literal syntax with `[]`, assigning a length to an empty array, and literal syntax with explicit length assignment.

**Test Cases**

Each test case consists of a single line of code that creates an array with 1000 elements. The code is then executed repeatedly to measure performance.

1. **Array Constructor**: `var arr = new Array(n);`
	* This approach creates an empty array and then assigns the length of the array using the `n` variable.
	* Pros: Simple, straightforward way to create an array.
	* Cons: May incur additional overhead due to the need to assign a length.
2. **Literal Syntax**: `var arr = [];`
	* This approach creates an empty array and then uses the `push()` method to add elements.
	* Pros: Lightweight, efficient way to create an array.
	* Cons: Requires repeated calls to `push()`, which can be slower than assigning a length.
3. **Assign by Index**: `var arr = [];`
	* This approach creates an empty array and then assigns values to each index using the `[]` syntax.
	* Pros: Simple, straightforward way to create an array with initialized values.
	* Cons: May incur additional overhead due to the need to access and modify individual elements.
4. **Explicit Length**: `var arr = []; arr.length = n;`
	* This approach creates an empty array and then assigns a length using the `length` property.
	* Pros: Efficient way to create an array with a fixed size, as it avoids repeated calls to `push()`.
	* Cons: May incur additional overhead due to the need to access and modify the `length` property.

**Library Used**

None of the test cases explicitly use a library. However, some browsers may include libraries or extensions that could affect performance.

**Special JS Features/ Syntax**

The benchmark does not specifically test any special JavaScript features or syntax, such as async/await, let/const, or arrow functions.

**Benchmark Results**

The latest benchmark results show the following performance data:

| Test Name | Executions Per Second |
| --- | --- |
| Array literal (explicit length) - 1000 items | 564172.1875 |
| Array constructor - 1000 items | 227036.078125 |
| Array literal (assign by index) - 1000 items | 158590.953125 |
| Array literal - 1000 items | 150661.484375 |

The results indicate that the `Array literal (explicit length)` approach is the fastest, followed closely by the `Array constructor` approach.

**Alternatives**

Other alternatives to create arrays in JavaScript include:

* Using a library like Lodash or Underscore.js to create arrays with various methods and utilities.
* Utilizing the `Array.from()` method to create an array from an iterable source, such as an array of numbers or strings.
* Leveraging modern JavaScript features like arrow functions or template literals to create arrays with concise syntax.

Keep in mind that the choice of array creation approach depends on specific use cases and performance requirements.

Array constructor vs literal performance - 1000 items (version: 0)

Comparing performance of: `Array constructor - 1000 items vs Array literal - 1000 items vs Array literal (assign by index) - 1000 items vs Array literal (explicit length) - 1000 items`

Created: 9 years ago by: Registered User

Go to the latest result

Array constructor - 1000 items

Array literal - 1000 items

Array literal (assign by index) - 1000 items

Array literal (explicit length) - 1000 items

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Array constructor vs literal performance - 1000 items (version: 0)

Comparing performance of: Array constructor - 1000 items vs Array literal - 1000 items vs Array literal (assign by index) - 1000 items vs Array literal (explicit length) - 1000 items

Created: 9 years ago by: Registered User

Go to the latest result

Array constructor - 1000 items

Array literal - 1000 items

Array literal (assign by index) - 1000 items

Array literal (explicit length) - 1000 items

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: `Array constructor - 1000 items vs Array literal - 1000 items vs Array literal (assign by index) - 1000 items vs Array literal (explicit length) - 1000 items`