Benchmark: Array.from() vs new Array(), filling with index

Tests:

new Array(), size 100
const a = new Array(100); for(i = 0; i < a.length; ++i) a[i] = i;
new Array(), size 1000
const a = new Array(1000); for(i = 0; i < a.length; ++i) a[i] = i;
new Array(), size 10000
const a = new Array(10000); for(i = 0; i < a.length; ++i) a[i] = i;
Array.from(), size 100
const a = Array.from({length: 100}, (_, i) => i)
Array.from(), size 1000
const a = Array.from({length: 1000}, (_, i) => i)
Array.from(), size 10000
const a = Array.from({length: 10000}, (_, i) => i)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new Array(), size 100
new Array(), size 1000
new Array(), size 10000
Array.from(), size 100
Array.from(), size 1000
Array.from(), size 10000

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what is being tested.

**Benchmark Description**

The benchmark is designed to compare two ways of creating arrays with different values in each position: using `new Array()` followed by a loop, or using `Array.from()` with an object that has a `length` property and a callback function that returns the desired value for each index.

**Options Compared**

There are four options being compared:

1. **new Array(), size X**: This method creates an array of a specified size using the `new Array()` constructor, and then fills it with values using a loop.
2. **Array.from(), size X**: This method uses the `Array.from()` function to create an array from an iterable (in this case, an object) that has a `length` property. The callback function passed to `Array.from()` specifies the value for each index.

**Pros and Cons**

1. **new Array(), size X**:
	* Pros: This method is straightforward and easy to understand.
	* Cons: It requires creating an array of a specific size, which can be less efficient than using `Array.from()`.
2. **Array.from(), size X**:
	* Pros: This method is more efficient because it doesn't require creating an array of a specific size beforehand. Additionally, it allows for more flexibility in terms of the values being filled into the array.
	* Cons: It requires passing an object with a `length` property and a callback function, which can be less intuitive for some developers.

**Library**

The `Array.from()` method is part of the ECMAScript standard and has been supported by most modern browsers since its introduction in ECMAScript 2015 (ES6). Its purpose is to create an array from an iterable object that has a `length` property, or from an array-like object.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntax used in this benchmark. It's written in plain JavaScript and uses standard methods and data structures.

**Other Alternatives**

If you wanted to create arrays with different values in each position, other methods could be used, such as:

* Using the `map()` method: `const a = new Array(100).map((_, i) => i);`
* Using a custom function: `function fillArray(size) { const arr = []; for (let i = 0; i < size; i++) arr.push(i); return arr; }; const a = fillArray(100);`

However, these methods may not be as efficient or straightforward to use as the `new Array()` and `Array.from()` methods used in this benchmark.

Related benchmarks:

Array.from() vs new Array(), filling with index (version: 0)

Testing the difference between creating arrays with different values in each position.

Comparing performance of: new Array(), size 100 vs new Array(), size 1000 vs new Array(), size 10000 vs Array.from(), size 100 vs Array.from(), size 1000 vs Array.from(), size 10000

Created: 2 years ago by: Guest

Jump to the latest result

new Array(), size 100

new Array(), size 1000

new Array(), size 10000

Array.from(), size 100

Array.from(), size 1000

Array.from(), size 10000

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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