Benchmark: fill vs from vs from object

Tests:

fill
Array(10000).fill().map((_, i) => i+1)
from
Array.from(Array(10000), (_, i) => i+1)
from object
Array.from({length: 10000}, (_, i) => i+1)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
fill
from
from object

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 97 on Fedora

View result in a separate tab

Test name	Executions per second
fill	4407.2 Ops/sec
from	1501.3 Ops/sec
from object	1045.7 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to explain what's being tested in this benchmark.

**Benchmark Overview**

The benchmark measures the performance of three different approaches for creating an array of numbers:

1. `Array.fill()`: Fills an existing array with a specified value.
2. `Array.from()` without an object (i.e., only using the spread operator): Creates a new array from an iterable.
3. `Array.from()` with an object (i.e., using the `Object` constructor to create an object and then passing it to `Array.from()`: Creates a new array from an iterable.

**Options Compared**

The benchmark compares the performance of these three approaches:

* **Pro's and Con's:**
	+ `Array.fill()`: Pros:
		- Fast (since it's just filling an existing array with a value)
		- Simple to implement
		Cons:
			- Requires an existing array
			- Can be slow if the array is very large or complex
	+ `Array.from()` without an object: Pros:
		- Fast (since it's using a V8-specific internal implementation that's optimized for performance)
		- Flexible (can create arrays from any iterable, including generators and promises)
		Cons:
			- Requires modern browsers (Chrome 97+) to use
			- Can be slower than `Array.fill()` if the input iterable is very large or complex
	+ `Array.from()` with an object: Pros:
		- Flexible (can create arrays from any iterable, including objects)
		- Suitable for use cases where an existing array is not available
		Cons:
			- Slower than `Array.fill()` and the simple `Array.from()`
			- Requires more memory to store the object being created
**Library/Functionality Used**

In this benchmark, no external libraries or functions are used. However, it's worth noting that `Array.from()` is a built-in JavaScript function that was introduced in ECMAScript 2015.

**Special JS Features/Syntax**

There are no special JavaScript features or syntax being tested in this benchmark. The focus is on comparing the performance of different array creation approaches using standard JavaScript features.

**Alternatives**

If you're interested in exploring alternative approaches to creating arrays, here are a few options:

* Using `Array.prototype.push()`: Instead of creating an array and then filling it with values, you could use `push()` to add elements to an existing array. This approach would require modifying the original array.
* Using `Uint8Array` or other typed arrays: Depending on your specific use case, using a typed array like `Uint8Array` might be more efficient than creating an untyped array using `Array`.
* Using `web Workers`: If you need to create very large arrays and are concerned about performance, you could consider using web workers to offload the array creation task to a separate thread.

Keep in mind that these alternatives may not offer significant performance benefits over the approaches being compared in this benchmark.

Related benchmarks:

fill vs from vs from object (version: 0)

Comparing performance of: fill vs from vs from object

Created: 2 years ago by: Guest

Jump to the latest result

fill

from

from object

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