Benchmark: Array constructor vs literal performance - 100000 items

Script Preparation code:

var n = 100000;

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 one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The benchmark compares the performance of four ways to create an array in JavaScript: using the `new Array()` constructor, literal syntax (`[]`), assigning elements by index (`arr[i] = new Person(i + '', i)`), and explicit length assignment (`arr.length = n; arr[i] = new Person(i + '', i)`).

**Options Compared**

1. **Array Constructor**: Creates an array using the `new Array()` constructor.
2. **Literal Syntax**: Creates an empty array using square brackets (`[]`).
3. **Assign by Index**: Assigns elements to the array using the syntax `arr[i] = new Person(i + '', i)`.
4. **Explicit Length Assignment**: Sets the length of the array using `arr.length = n;` and then assigns elements using `arr[i] = new Person(i + '', i)`.

**Pros and Cons**

1. **Array Constructor**:
	* Pros: Can create arrays with a specified initial size.
	* Cons: May have performance overhead due to object creation.
2. **Literal Syntax**:
	* Pros: Fast and lightweight, creates an empty array.
	* Cons: Limited control over the array's properties and behavior.
3. **Assign by Index**:
	* Pros: Allows for dynamic array growth and can be more efficient for large arrays.
	* Cons: Requires explicit indexing, which can lead to errors if not done correctly.
4. **Explicit Length Assignment**:
	* Pros: Provides a balance between performance and control over the array's size.
	* Cons: May have some overhead due to setting the length property.

**Library Usage**

The benchmark uses an external library called `Person` which is not explicitly mentioned in the provided JSON. Assuming it's a custom class, its purpose is likely to represent a person with name and age properties.

**Special JavaScript Feature/Syntax**

None of the options mentioned in the benchmark require special JavaScript features or syntax that would affect their performance.

**Alternatives**

Other alternatives for creating arrays in JavaScript include:

1. `Array.from()`: Creates an array from an iterable, such as an array expression.
2. `Array.prototype.slice()`: Creates a shallow copy of a portion of an array.
3. Using a library like Lodash or Underscore.js which provide alternative array creation methods.

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

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/53.0.2785.143 Safari/537.36

Browser/OS: Chrome 53 on Mac OS X 10.12.0

View result in a separate tab

Test name	Executions per second
Array constructor - 100000 items	23.5 Ops/sec
Array literal - 100000 items	23.3 Ops/sec
Array literal (assign by index) - 100000 items	24.8 Ops/sec
Array literal (explicit length) - 100000 items	26.2 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 one month ago):