Benchmark: array construction comparison

Tests:

new Array()
new Array(500)
Array.from()
Array.from({ length: 500 })
[] + length
let a = []; a.length = 500;
[] + fill undefined
[].fill(undefined, 0, 500)
[] + fill void
[].fill(void 0, 0, 500)
new Array() zeroed
new Array().fill(0, 0, 500)
Array.from zeroes
Array.from({ length: 500 }, () => 0)
[] + fill zeroes
[].fill(0, 0, 500)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new Array()
Array.from()
[] + length
[] + fill undefined
[] + fill void
new Array() zeroed
Array.from zeroes
[] + fill zeroes

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON and explain what's being tested, compared options, pros/cons, library usage, special JS features, and other considerations.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The benchmark in question compares different ways of creating an array with 500 elements.

**Test Cases**

There are eight test cases:

1. `new Array(500)`
2. `Array.from({ length: 500 })`
3. `let a = [];\r\na.length = 500;` (not exactly creating an array, but using the `length` property to set the size)
4. `[].fill(undefined, 0, 500)`
5. `[].fill(void 0, 0, 500)`
6. `new Array().fill(0, 0, 500)`
7. `Array.from({ length: 500 }, () => 0)`
8. `[].fill(0, 0, 500)`

**Options Compared**

Each test case compares a different way of creating an array with 500 elements:

* **Dynamic Array Creation**: `new Array(500)` and `Array.from({ length: 500 })`
	+ Pros: efficient and concise
	+ Cons: may not be supported in older browsers or environments that don't support modern JavaScript features
* **Length Property**: `let a = [];\r\na.length = 500;` (not exactly creating an array, but using the `length` property)
	+ Pros: widely supported and compatible with older browsers
	+ Cons: less efficient than dynamic array creation
* **fill() Method**: `[].fill(undefined, 0, 500)` and `[].fill(void 0, 0, 500)`
	+ Pros: concise and can be used to set multiple values at once
	+ Cons: may not work as expected in some browsers or environments that don't support the `fill()` method
* **Zero-Filled Array Creation**: `new Array().fill(0, 0, 500)` and `[].fill(0, 0, 500)`
	+ Pros: efficient and concise
	+ Cons: may not be supported in older browsers or environments that don't support modern JavaScript features

**Library Usage**

None of the test cases use any external libraries.

**Special JS Features**

Some test cases use special JavaScript features:

* **Array.from() Method**: used in tests 2, 7
* **Fill() Method**: used in tests 4 and 8
* **Arrow Functions**: used in test 7

These features are widely supported in modern browsers and environments, but may not work in older browsers or environments that don't support them.

**Other Considerations**

* The benchmark results show that Chrome 112 has the fastest execution times for most of the tests.
* Some tests (e.g. `let a = [];\r\na.length = 500;`) are not exactly creating an array, but using the `length` property to set the size.

**Alternatives**

If you're looking for alternatives to MeasureThat.net, some options include:

* jsbench.org: another popular JavaScript benchmarking platform
* jsperf.com: a simple JavaScript performance testing tool
* browserstack.com: a cloud-based testing and deployment platform that includes support for various browsers and environments

Keep in mind that these alternatives may not provide the same level of customization or control as MeasureThat.net.

Latest run results:

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

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

Browser/OS: Chrome 112 on Windows

View result in a separate tab

Test name	Executions per second
new Array()	3596301.0 Ops/sec
Array.from()	52363.2 Ops/sec
[] + length	4487997.0 Ops/sec
[] + fill undefined	8923331.0 Ops/sec
[] + fill void	44257096.0 Ops/sec
new Array() zeroed	8672663.0 Ops/sec
Array.from zeroes	47012.9 Ops/sec
[] + fill zeroes	45921904.0 Ops/sec

Related benchmarks:

array construction comparison (version: 0)

Comparing performance of: new Array() vs Array.from() vs [] + length vs [] + fill undefined vs [] + fill void vs new Array() zeroed vs Array.from zeroes vs [] + fill zeroes

Created: one year ago by: Registered User

Jump to the latest result

new Array()

Array.from()

[] + length

[] + fill undefined

[] + fill void

new Array() zeroed

Array.from zeroes

[] + fill zeroes

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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