Benchmark: Create empty array without elements

Tests:

[]
a = []
new Array()
a = new Array()
Array()
a = Array()
Array.of()
a = Array.of()
JSON.parse()
a = JSON.parse('[]')
Object.create(Array.prototype)
a = Object.create(Array.prototype)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
[]
new Array()
Array()
Array.of()
JSON.parse()
Object.create(Array.prototype)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
[]	8095964.5 Ops/sec
new Array()	4598049.0 Ops/sec
Array()	4647101.0 Ops/sec
Array.of()	3456419.5 Ops/sec
JSON.parse()	3668509.5 Ops/sec
Object.create(Array.prototype)	3304181.2 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark you provided tests different methods of creating an empty array in JavaScript. The methods compared in this benchmark include:

1. **`a = []`** – Array literal syntax.
2. **`a = new Array()`** – Constructor function for the Array type.
3. **`a = Array()`** – Calls the Array constructor without the `new` keyword.
4. **`a = Array.of()`** – Static method that creates a new array instance from a variable number of arguments.
5. **`a = JSON.parse('[]')`** – Parses a string as JSON, creating an array from a JSON representation of an empty array.
6. **`a = Object.create(Array.prototype)`** – Creates a new object with the Array prototype, resulting in an array-like object.

### Comparison of Methods

**1. `[]` (Array Literal Syntax)**
   - **Pros:** The most straightforward and common way to create an array. It is succinct and widely understood among developers.
   - **Cons:** None significant; it is generally the preferred method.

**2. `new Array()` (Constructor Syntax)**
   - **Pros:** Can be used to create arrays with a specific length or with elements directly. It supports passing in a size, which creates an array of that length.
   - **Cons:** Less intuitive than the array literal and can sometimes lead to unexpected behavior if used with a single numeric argument (creates an array of that length instead of the value).

**3. `Array()` (Without `new`)**
   - **Pros:** Similar to using the constructor.
   - **Cons:** It is not conventional to use the constructor without `new`, which can lead to confusion. It behaves the same as `new Array()` when called without arguments.
  
**4. `Array.of()` (Static Method)**
   - **Pros:** Provides a more predictable way to create arrays without ambiguity in regard to single numeric arguments. It returns a new array instance with the provided arguments as elements.
   - **Cons:** Slightly less familiar compared to the array literal; not supported in very old JavaScript environments.

**5. `JSON.parse('[]')`**
   - **Pros:** A unique method to create an empty array if you're dealing with JSON data or types. It shows how JSON strings can turn into JavaScript objects.
   - **Cons:** Generally overkill for simply creating an empty array, as it introduces unnecessary complexity.

**6. `Object.create(Array.prototype)`**
   - **Pros:** This method creates an object that inherits from Array but doesn't create an actual array in the traditional sense.
   - **Cons:** The returned object does not have a length property that typical arrays have, making it less functional as a standard array.

### Benchmark Results Overview

The benchmark results show that the fastest method was the array literal syntax `[]`, with about **8.1 million executions per second**. The other methods performed significantly slower, with methods like `Array()`, `new Array()`, and `Array.of()` showing around **4-5 million executions per second**, while `JSON.parse('[]')` and `Object.create(Array.prototype)` were at the bottom of the performance stats.

### Alternatives and Considerations

Other alternatives for creating an array include using utility libraries such as lodash or underscore, which offer utility functions to handle arrays but generally rely on standard JavaScript methods under the hood.

You may also consider various array manipulation techniques, such as initializing with default values or using `Array.fill()` once the array is created, thereby still requiring a method to create the initial empty array.

The results from the benchmark highlight performance considerations when deciding which method to use in production code. For general use cases where simplicity and readability are paramount, `[]` remains the best choice. For specific scenarios involving JSON manipulation, parsing methods like `JSON.parse()` might be appropriate, but performance trade-offs should be evaluated.

Related benchmarks:

Create empty array without elements (version: 1)

Comparing performance of: [] vs new Array() vs Array() vs Array.of() vs JSON.parse() vs Object.create(Array.prototype)

Created: one month ago by: Guest

Jump to the latest result

[]

new Array()

Array()

Array.of()

JSON.parse()

Object.create(Array.prototype)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):