Benchmark: Creation of new Array: Array.from vs. new Array

Script Preparation code:

var size = 5000;

Tests:

Array.from
const arr = Array.from({ length: size });
new Array
const arr = new Array(size);

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

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

Browser/OS: Chrome 94 on Windows

View result in a separate tab

Test name	Executions per second
Array.from	3452.1 Ops/sec
new Array	337100.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the JavaScript microbenchmark on MeasureThat.net.

**Benchmark Overview**

The benchmark compares two approaches for creating new JavaScript arrays: `Array.from()` and the traditional `new Array()`. The goal is to measure which approach is faster, more efficient, or both.

**Options Compared**

Two options are being compared:

1. **`Array.from({ length: size })`**: This method creates a new array by mapping an array with `length` property to create the desired number of elements.
2. **`new Array(size)`**: This method creates a new array using the constructor syntax, where `size` is the initial length of the array.

**Pros and Cons**

Here's a brief overview of each approach:

*   **`Array.from()`**: Pros:
    *   More concise and readable syntax.
    *   Can create arrays from other iterables (e.g., strings, sets).
    Cons:
    *   May have performance overhead due to function call and mapping process.
*   **`new Array(size)`**: Pros:
    *   Faster execution time since it avoids the function call and mapping overhead.
    Cons:
    *   Less readable and more verbose syntax.

**Library**

There is no specific library being used in this benchmark. The `Array.from()` method is a built-in JavaScript method, while the `new Array(size)` approach relies on the constructor syntax.

**Special JS Feature or Syntax**

Neither of the approaches uses any special JavaScript feature or syntax. Both are standard ES6+ features.

**Other Alternatives**

If you're interested in exploring other alternatives for creating arrays, here are a few options:

1.  **`Array.create()`**: This method is similar to `new Array(size)` but returns an array object instead of an array constructor.
2.  **`Array.prototype.slice()`**: You can create an array by calling the `slice()` method on an existing array and specifying the desired length.

Here's some sample code demonstrating these alternatives:

```javascript
// Array.create()
var arr1 = Array.create(10);
console.log(arr1.length); // Output: 10

// Array.prototype.slice()
var arr2 = [1, 2, 3];
var newarr = arr2.slice(0, 5);
console.log(newarr.length); // Output: 5
```

Keep in mind that the performance characteristics of these alternatives might differ from `new Array(size)` and `Array.from()`, so be sure to benchmark them if necessary.

Related benchmarks:

Creation of new Array: 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 2 months ago):