Benchmark: Initializing array with n undefined items

Script Preparation code:

var n = 100000; // 100k

Tests:

[...Array(n).keys()].map(k => undefined)
[...Array(n).keys()].map(k => undefined);
Array.apply(null, { length: 4 })
Array.apply(null, { length: n });
Array.from
Array.from({ length: n }, () => undefined);
Array(n).fill(undefined)
Array(n).fill(undefined)
for loop push
const arr = []; for (let i = 0; i < n; i++) { arr.push(undefined); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
[...Array(n).keys()].map(k => undefined)
Array.apply(null, { length: 4 })
Array.from
Array(n).fill(undefined)
for loop push

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/134.0.0.0 Safari/537.36

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
[...Array(n).keys()].map(k => undefined)	440.9 Ops/sec
Array.apply(null, { length: 4 })	866.8 Ops/sec
Array.from	481.8 Ops/sec
Array(n).fill(undefined)	5579.1 Ops/sec
for loop push	1232.7 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition:**

The benchmark measures how fast JavaScript engines can initialize an array with `n` undefined items using different methods. The goal is to see which method is the fastest.

**Methods Compared:**

1. **Spread Operator**: `[...Array(n).keys()].map(k => undefined)`
2. **Array.prototype.apply()**: `Array.apply(null, { length: n })`
3. **Array.from()**: `Array.from({ length: n }, () => undefined)`
4. **Array.prototype.fill()**: `Array(n).fill(undefined)`
5. **For loop with push()**: `const arr = []; for (let i = 0; i < n; i++) { arr.push(undefined); }`

**Pros and Cons of Each Approach:**

1. **Spread Operator**:
	* Pros: Efficient, concise syntax.
	* Cons: May not be as optimized by modern engines.
2. **Array.prototype.apply()**:
	* Pros: Can be more efficient than the spread operator due to its ability to optimize array creation.
	* Cons: Less intuitive and verbose syntax.
3. **Array.from()**:
	* Pros: Newer method introduced in ES6, potentially optimized by modern engines.
	* Cons: May not be as widely supported or understood.
4. **Array.prototype.fill()**:
	* Pros: Efficient for large arrays, as it can fill the array with a single operation.
	* Cons: May not work correctly if `n` is not a power of 2.
5. **For loop with push()**:
	* Pros: Simple, intuitive syntax.
	* Cons: Generally slower than other methods due to the overhead of the loop.

**Library Used:**

None explicitly mentioned in the benchmark definition. However, some modern JavaScript engines might use optimized internal arrays or data structures that are not visible through the public API.

**Special JS Features or Syntax:**

The spread operator (`[...Array(n).keys()].map(k => undefined)`) is a relatively new feature introduced in ECMAScript 2015 (ES6). It's designed to provide a concise way to create arrays from iterables. While it's not a special syntax, it's an optimization technique that can be used in various contexts.

**Other Alternatives:**

If you need to initialize an array with undefined items, other alternatives might include:

* Using `Array(n).map(() => undefined)` or `Array(n).fill(undefined)`
* Creating an array from a generator function or an iterable
* Utilizing WebAssembly or other low-level optimizations (not recommended for most use cases)

Keep in mind that the choice of method ultimately depends on your specific requirements, performance needs, and personal preference.

Related benchmarks:

Initializing array with n undefined items (version: 0)

worth to note that the maximum callstack size is exceeded for the first test case (spread operator) with n = 1 million

Comparing performance of: [...Array(n).keys()].map(k => undefined) vs Array.apply(null, { length: 4 }) vs Array.from vs Array(n).fill(undefined) vs for loop push

Created: 4 years ago by: Guest

Jump to the latest result

[...Array(n).keys()].map(k => undefined)

Array.apply(null, { length: 4 })

Array.from

Array(n).fill(undefined)

for loop push

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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