Benchmark: Array.from VS Array

Tests:

Array.from with length
let arr = Array.from({ length: 10 ** 7 }, () => true);
Array(length)
let arr = Array(10 ** 7).fill(true);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.from with length
Array(length)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36

Browser/OS: Chrome 90 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.from with length	3.2 Ops/sec
Array(length)	45.1 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 world of JavaScript microbenchmarks.

The provided JSON represents two test cases that compare the performance of creating arrays using different methods: `Array.from` and plain array creation (`Array()`). We'll break down each test case, explain what's being compared, and discuss the pros and cons of these approaches.

**Test Case 1: Array.from with length**

```javascript
let arr = Array.from({ length: 10 ** 7 }, () => true);
```

In this test case, `Array.from()` is used to create an array from a specified length. The `length` property creates an array with the given number of elements, and `() => true` is an arrow function that returns `true` for each element.

**Pros:**

1. Explicit control over the array's contents.
2. Can be more readable, especially when working with complex data structures.

**Cons:**

1. May lead to slower performance due to the overhead of creating and executing the callback function.
2. Can result in larger memory allocations if not handled properly.

**Test Case 2: Array(length)**

```javascript
let arr = Array(10 ** 7).fill(true);
```

In this test case, plain array creation is used to create an array with a specified length and fill it with a value (in this case, `true`).

**Pros:**

1. Faster performance compared to `Array.from()` due to the absence of callback function overhead.
2. Can be more efficient in terms of memory allocation.

**Cons:**

1. Less explicit control over the array's contents.
2. May lead to slower performance if the fill value is complex or computationally expensive.

Now, let's examine some additional options that might be considered:

* Using `Array()` with a custom constructor: This approach allows for more fine-grained control over the array's contents but can also add unnecessary complexity and overhead.
* Using libraries like `lodash` or `ramda`: These libraries provide various methods for creating arrays, which might offer performance benefits in certain scenarios.

The provided benchmark results show that Chrome 90 on a Desktop (Mac OS X 10.15.7) favors the plain array creation approach (`Array(length)`), with an execution rate of approximately 3.2 executions per second. In contrast, `Array.from()` with length yields around 45.1 executions per second.

Keep in mind that these results are specific to Chrome 90 on a Desktop and might not be representative of other browsers or environments. The choice between these approaches ultimately depends on the specific requirements and constraints of your project.

In summary:

* If explicit control over the array's contents is essential, `Array.from()` with length might be a better choice.
* If faster performance is critical, plain array creation (`Array(length)`) might be the way to go.
* Consider the trade-offs between readability, memory allocation, and execution speed when making your decision.

Related benchmarks:

Array.from VS Array (version: 0)

Comparing performance of: Array.from with length vs Array(length)

Created: 3 years ago by: Guest

Jump to the latest result

Array.from with length

Array(length)

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