Benchmark: spread vs ArrayFrom object

Script Preparation code:

var array = [{
    price: 200
}, {
    price: 100
}, {
    price: 400
}, {
    price: 8500
}, {
    price: 12500
}, {
    price: 50
}, {
    price: 20
}]

Tests:

spread
var spread = [...array]
arrayFrom
var from = Array.from(array)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
spread
arrayFrom

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 its results.

**What is being tested?**

MeasureThat.net is testing two approaches to create an array from an existing array in JavaScript: using the spread operator (`...`) and `Array.from()`. The test case uses a predefined array with 7 elements, each containing a price value.

**Options compared**

There are two options being compared:

1. **Spread Operator (`...`)**: This operator creates a new array by spreading out the elements of an existing array.
2. **Array.from()**: This method returns a new array created from an array-like or iterable object.

**Pros and Cons of each approach**

1. **Spread Operator (`...`)**:
	* Pros:
		+ Simple and intuitive syntax
		+ Fast execution (O(1) amortized)
	* Cons:
		+ Can be less readable for complex cases
		+ May not work as expected with certain data types or objects
2. **Array.from()**:
	* Pros:
		+ More explicit and readable syntax
		+ Works well with array-like or iterable objects
	* Cons:
		+ May have overhead due to method call and object creation (O(1) average)
		+ Can be slower than the spread operator for simple cases

**Library usage**

None.

**Special JS feature/syntax**

The benchmark uses the spread operator (`...`) and `Array.from()`, which are both supported in modern JavaScript versions.

**Benchmark preparation code**

The script prepares an array with 7 elements, each containing a price value. This array is then used to create new arrays using the two tested approaches: spread operator and `Array.from()`.

**Individual test cases**

There are two individual test cases:

1. **"spread"`**: Creates a new array by spreading out the elements of the original array.
2. **"arrayFrom"`**: Uses the `Array.from()` method to create a new array from the original array.

**Latest benchmark result**

The latest benchmark results show that:

* The spread operator (`...`) is faster, with an average execution per second (EPS) of 10777347.0.
* The `Array.from()` method is slower, with an EPS of 4209034.0.

Other alternatives to the spread operator and `Array.from()`

If you need to create a new array from an existing array in JavaScript, other options include:

1. **`slice()`**: Creates a shallow copy of a portion of an array.
2. **`map()`**: Creates a new array with the results of applying a provided function on every element in this array.
3. **`reduce()`**: Creates a new array with the results of applying a provided function on every element in this array.

However, these alternatives may have different performance characteristics and use cases compared to the spread operator and `Array.from()`.

Related benchmarks:

spread vs ArrayFrom object (version: 0)

Comparing performance of: spread vs arrayFrom

Created: 2 years ago by: Guest

Jump to the latest result

spread

arrayFrom

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