Benchmark: Array constructor vs literal performance - 100000 items

Tests:

Array constructor - 100000 items
var n = 100000; var arr = new Array(n); for (var i = 0; i < n; i++) { arr[i] = i; }
Array literal - 100000 items
var n = 100000; var arr = []; for (var i = 0; i < n; i++) { arr.push(i); }
Array literal (assign by index) - 100000 items
var n = 100000; var arr = []; for (var i = 0; i < n; i++) { arr[i] = i; }
Array literal (explicit length) - 100000 items
var n = 100000; var arr = []; arr.length = n; for (var i = 0; i < n; i++) { arr[i] = i; }
Array constructor (no new) - 100000 items
var n = 100000; var arr = Array(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 - 100000 items
Array literal - 100000 items
Array literal (assign by index) - 100000 items
Array literal (explicit length) - 100000 items
Array constructor (no new) - 100000 items

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 8 years ago)

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

Browser/OS: Chrome 56 on Windows 7

View result in a separate tab

Test name	Executions per second
Array constructor - 100000 items	1079.6 Ops/sec
Array literal - 100000 items	633.6 Ops/sec
Array literal (assign by index) - 100000 items	637.7 Ops/sec
Array literal (explicit length) - 100000 items	1450.6 Ops/sec
Array constructor (no new) - 100000 items	1301.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is being tested?**

The benchmark measures the performance of creating and populating arrays in JavaScript using different approaches:

1. **Array constructor**: Using the `new Array()` syntax to create an array, followed by assigning values to its elements.
2. **Literal syntax**: Creating an array directly using square brackets `[]`, followed by pushing or assigning values to its elements.
3. **Assign-by-index syntax**: Creating an empty array and then assigning values to its elements using indexing (`arr[i] = i`).
4. **Explicit length syntax**: Creating an empty array and setting its length explicitly, followed by assigning values to its elements.

**Options compared**

The benchmark compares the performance of these four approaches:

* **Array constructor (no new)**: Creates an array directly without the `new` keyword.
* **Array literal (assign by index)**: Assigns values to an empty array using indexing (`arr[i] = i`).
* **Array literal (explicit length)**: Sets the length of an empty array explicitly and then assigns values to its elements.

**Pros and cons**

1. **Array constructor**: Pros - concise syntax, Cons - may incur a slight overhead due to the `new` keyword.
2. **Literal syntax**: Pros - concise and flexible, Cons - can be slower than the other approaches since it involves creating an array and then pushing values into it.
3. **Assign-by-index syntax**: Pros - simple and efficient, Cons - requires indexing which can be less readable than other approaches.
4. **Explicit length syntax**: Pros - explicit control over array size, Cons - may require more code to set the length.

**Library usage**

None of the benchmarked approaches use any external libraries.

**Special JavaScript features or syntax**

This benchmark does not utilize any special JavaScript features or syntax beyond the basic syntax for creating and manipulating arrays. However, it's worth noting that using `let` or `const` instead of `var` can affect performance in some cases, but this is not addressed in this specific benchmark.

**Other alternatives**

If you're looking for alternative approaches to creating and populating arrays, consider the following:

* Using `Array.from()` to create an array from an iterable source.
* Utilizing `Map` or `Set` data structures if you need to store large amounts of data with key-value pairs or unique values.

Keep in mind that performance differences between these approaches may vary depending on your specific use case and JavaScript environment.

Related benchmarks:

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

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

Created: 8 years ago by: Guest

Jump to the latest result

Array constructor - 100000 items

Array literal - 100000 items

Array literal (assign by index) - 100000 items

Array literal (explicit length) - 100000 items

Array constructor (no new) - 100000 items

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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