Benchmark: Array.from() vs Array()

Tests:

new Array()
Array(500).fill({ test: "123", })
Array.from()
Array.from({ length: 500 }, () => ({ test: "123" }))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new Array()
Array.from()

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36

Browser/OS: Chrome 117 on Linux

View result in a separate tab

Test name	Executions per second
new Array()	820129.1 Ops/sec
Array.from()	30174.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**What is being tested?**

The benchmark compares two approaches to create filled arrays in JavaScript: `new Array()` and `Array.from()`. The test case creates an array with 500 elements, each containing a single property `test` with value `"123"`.

**Options compared:**

Two options are being compared:

1. **`new Array()`**: This approach creates a new array using the constructor function `Array()`, specifying the length of the array as 500. The array is then filled with elements, each containing a single property `test`.
2. **`Array.from()`**: This approach uses the `from()` method to create an array from an iterable source, in this case, an arrow function that generates 500 elements.

**Pros and Cons:**

**`new Array()`**:

Pros:

* Simple and straightforward approach
* No dependencies on external libraries

Cons:

* Can be slower than `Array.from()` due to the need to create a new array object using the constructor function
* May not be optimized for performance, especially for large arrays

**`Array.from()`**:

Pros:

* More efficient and faster than `new Array()`, as it leverages the optimized `from()` method under the hood
* Can handle more complex iterable sources, such as arrays or strings

Cons:

* Requires a dependency on the `Array.prototype.from()` method, which may not be available in older browsers
* May have slightly higher memory overhead due to the creation of an intermediate array object

**Other considerations:**

The test cases use JavaScript's `length` property and object literal syntax (e.g., `{\r\n\ttest: "123"\r\n}`). These features are widely supported across modern browsers and versions of JavaScript.

**Library usage:**

No external libraries are required for this benchmark, as it only uses built-in JavaScript features.

**Special JS feature or syntax:**

The test cases use the arrow function (`() => ({...})`) to generate the iterable source for `Array.from()`. This is a modern JavaScript feature that was introduced in ECMAScript 2015 (ES6).

In summary, this benchmark compares two approaches to create filled arrays in JavaScript, highlighting the trade-offs between simplicity and performance. While `new Array()` is straightforward but may be slower, `Array.from()` is more efficient but requires a dependency on the optimized `from()` method.

Related benchmarks:

Array.from() vs Array() (version: 0)

Testing the difference between creating filled arrays.

Comparing performance of: new Array() vs Array.from()

Created: one year ago by: Guest

Jump to the latest result

new Array()

Array.from()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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