Benchmark: Array.from vs new Array

Tests:

Array.from
Array.from({ length: 4 }, () => new Array(4).fill(0));
new Array
new Array(4).fill(0).map(() => new Array(4).fill(0));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.from
new Array

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 break down the provided benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is defined as comparing two approaches to create an array of arrays: `Array.from` versus creating an array with `new Array`.

In JavaScript, both methods are used to achieve similar results. However, they differ in how they're implemented and might have varying performance characteristics.

**Options being compared**

Two options are being compared:

1. **`Array.from({ length: 4 }, () => new Array(4).fill(0))`**: This method uses the `Array.from()` method to create an array of arrays. The callback function generates four arrays with zeros, and `Array.from()` collects these arrays into a single array.
2. **`new Array(4).fill(0).map(() => new Array(4).fill(0))`**: This method uses the `new Array()` constructor to create an empty array, fills it with zeros using `fill(0)`, and then maps over the array to generate four inner arrays.

**Pros and cons of each approach**

1. **`Array.from()`**:
	* Pros: concise and expressive syntax, can be easily modified or extended.
	* Cons: might incur additional overhead due to the creation of an intermediate array.
2. **`new Array()`**: 
	* Pros: allows for fine-grained control over the inner arrays (e.g., using `map()`).
	* Cons: more verbose and less concise, requires explicit typing.

**Library usage**

Neither method relies on a specific library. However, it's worth noting that some JavaScript engines might optimize or specialize these methods in certain contexts.

**Special JS features or syntax**

No special JavaScript features or syntax are being tested here; the focus is solely on comparing two simple array creation methods.

**Other alternatives**

For creating arrays of arrays, other approaches exist:

1. **`Array.prototype.map()`**: Similar to `new Array()`, but can be used on existing arrays.
2. **`Array.from()` with a custom function**: Can generate arrays with specific structures or properties.
3. **Native array creation methods**: Some browsers and environments provide native methods for creating arrays, like `Array.create()`.

Keep in mind that the performance characteristics of these alternatives might vary depending on the JavaScript engine and environment.

**Benchmark preparation code**

The provided benchmark preparation code is minimal, consisting only of an empty `Script Preparation Code` field. In a real-world scenario, this code would typically include any necessary setup or initialization for the benchmark, such as generating test data or configuring performance metrics.

Latest run results:

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

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

Browser/OS: Chrome 88 on Windows

View result in a separate tab

Test name	Executions per second
Array.from	452701.3 Ops/sec
new Array	654092.8 Ops/sec

Related benchmarks:

Array.from vs new Array (version: 0)

Comparing performance of: Array.from vs new Array

Created: 3 years ago by: Guest

Jump to the latest result

Array.from

new Array

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