Benchmark: Array.from vs Spread 100k

Tests:

Array.from
var fooSet = new Set(); for(var i=0;i<100_000;i++) { fooSet.add(i); } var other = Array.from(fooSet);
Spread
var fooSet = new Set(); for(var i=0;i<100_000;i++) { fooSet.add(i); } var other = [...fooSet];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.from
Spread

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's being tested.

**What is being tested?**

The provided JSON represents two individual test cases, each comparing two different ways to convert a Set object to an array: `Array.from` and the spread operator (`...`).

**Options compared:**

1. **Array.from**: A method on the Array prototype that creates a new array from an iterable or an array-like object.
2. **Spread operator (`...`)**: An operator used in JavaScript to create a new array by spreading the elements of another array or iterable.

**Pros and Cons:**

**Array.from:**

Pros:

* More explicit and readable way to convert an iterable to an array.
* Can handle more complex iterables, such as objects with custom iteration logic.
* Supports multiple iteration modes (e.g., `Array.from(arr, x => x * 2)`).

Cons:

* May be slower than the spread operator for small arrays or simple iterables.
* Requires a separate function call and creates an intermediate array.

**Spread operator (`...`):**

Pros:

* Faster than `Array.from` for small arrays or simple iterables.
* More concise and efficient way to create new arrays from existing ones.
* Less overhead compared to using a method call and creating an intermediate array.

Cons:

* Less readable and explicit, especially for complex iterables.
* Only supports a limited subset of iteration modes (e.g., `var arr = [1, 2]; var newArr = [...arr];`).

**Library:**

In the provided benchmark code, two libraries are used:

1. **Set**: A built-in JavaScript library that provides an efficient way to store and manipulate unique values.
2. **Array.from**: A built-in JavaScript method on the Array prototype.

Both libraries are part of the standard JavaScript library and don't require any additional installations or dependencies.

**Special JS feature/syntax:**

There is no special JavaScript feature or syntax used in this benchmark code. The examples only use basic JavaScript syntax, such as loops, arrays, sets, and literals.

**Alternatives:**

Other alternatives to compare with `Array.from` and the spread operator include:

1. **Array.prototype.slice()**: A built-in method on the Array prototype that creates a shallow copy of an array.
2. **Array.prototype.push()**: A built-in method on the Array prototype that appends elements to an array.
3. **For...of loop**: A newer way of iterating over arrays and iterables introduced in ECMAScript 2015 (ES6).

However, these alternatives are not directly comparable to `Array.from` and the spread operator in terms of performance and readability.

Keep in mind that this benchmark is focused on comparing two specific methods (`Array.from` and the spread operator) for converting sets to arrays. Other benchmarks may focus on different aspects or use more complex scenarios.

Related benchmarks:

Array.from vs Spread 100k (version: 0)

Comparing performance of: Array.from vs Spread

Created: 2 years ago by: Guest

Jump to the latest result

Array.from

Spread

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