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: 9 months 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

Test name	Executions per second
Array constructor - 1000 items	502700.4 Ops/sec
Array literal - 1000 items	576285.6 Ops/sec
Array literal (assign by index) - 1000 items	456635.2 Ops/sec
Array literal (explicit length) - 1000 items	457337.6 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.

Related benchmarks:

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

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