Benchmark: Array constructor vs literal performance - 100000 items

Script Preparation code:

var n = 10;

function Person(name, age) {
  this.name = name;
  this.age = age;
}

Tests:

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

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 dive into the world of JavaScript microbenchmarks.

**Benchmark Definition**

The provided JSON represents a benchmark definition, which outlines the test scenario and configuration. Here's what's tested:

* The creation of an array using different methods: constructor, literal (assign by index), literal (explicit length), and literal with assign by index.
* Each method is compared to see which one performs better.

**Options Compared**

The options being compared are:

1. **Array Constructor**: Creates an array using the `new Array()` syntax.
2. **Literal (Assign by Index)**: Creates an array by pushing elements into it using the `push()` method, without explicitly specifying the length.
3. **Literal (Explicit Length)**: Creates an array with a specified length using the `length` property and then pushes elements into it.
4. **Literal (assign by index)**: A combination of options 2 and 3, where the length is explicitly set before pushing elements.

**Pros and Cons**

Here's a brief analysis of each option:

1. **Array Constructor**:
	* Pros: Fast initialization, as it doesn't require additional memory allocations.
	* Cons: May not be suitable for large arrays, as it can lead to memory fragmentation.
2. **Literal (Assign by Index)**:
	* Pros: Efficient memory allocation and less memory fragmentation compared to constructor.
	* Cons: Requires multiple push() operations, which might be slower than a single initialization with the length property.
3. **Literal (Explicit Length)**:
	* Pros: Suitable for large arrays, as it allows efficient memory allocation and less memory fragmentation.
	* Cons: May require more memory upfront, and the push() operation can still lead to slower performance.
4. **Literal (assign by index) + Explicit Length**:
	* This option is a compromise between the previous two, but its performance might not be significantly better than either of the individual options.

**Library Used**

There is no explicit library mentioned in the benchmark definition. However, it's likely that the `Person` class used in the script preparation code is an internal implementation detail, and its actual purpose is not relevant to this benchmark.

**Special JavaScript Features/Syntax**

The benchmark uses:

* **Template literals**: Used to create string values for the `name` property of the `Person` object.
* **Arrow functions**: Used as a shorthand for function expressions in some test cases.

Overall, this benchmark provides insight into the performance differences between various array creation methods in JavaScript. By testing different approaches, developers can gain a better understanding of the most efficient way to create arrays and manage memory in their applications.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko

Browser/OS: IE 11 on Windows 7

View result in a separate tab

Test name	Executions per second
Array constructor - 100000 items	872285.1 Ops/sec
Array literal - 100000 items	946030.2 Ops/sec
Array literal (assign by index) - 100000 items	971685.2 Ops/sec
Array literal (explicit length) - 100000 items	915577.5 Ops/sec

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

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

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