Benchmark: array.from vs spread with set

Script Preparation code:

var arr = [];
for (var i = 0; i < 10000; i++) {
  arr.push(Math.floor(Math.random() * 1000));
}

Tests:

spread
const ss = new Set(arr) arr = [...ss]
Array.from
arr = Array.from(new Set(arr))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
spread
Array.from

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 what's being tested in this benchmark and explain the options, pros, cons, and considerations.

**Benchmark Overview**

The benchmark is designed to compare two approaches: using the spread operator (`...`) to convert a Set to an array, versus using `Array.from()` with a Set as its argument.

**Script Preparation Code**

The script preparation code creates an empty array `arr` and populates it with 10,000 random integers between 0 and 1000 using a `for` loop. This initializes the input data for both test cases.

**Html Preparation Code**

There is no HTML preparation code provided, which means that the benchmark focuses solely on JavaScript execution performance.

**Individual Test Cases**

The two test cases are:

1. **Spread**: The script uses the spread operator (`...`) to convert a Set created from `arr` back into an array.
```javascript
const ss = new Set(arr);
arr = [...ss];
```
2. **Array.from**: The script uses `Array.from()` with a Set as its argument to convert `arr` into an array.

**Library Usage**

Both test cases use the built-in JavaScript `Set` and `Array.prototype.push()` methods, which are part of the ECMAScript standard (ES6).

**Special JavaScript Features/Syntax**

There is no special JavaScript feature or syntax being tested in this benchmark. The focus is solely on comparing two basic array conversion approaches.

**Pros and Cons of Each Approach**

1. **Spread**: Using the spread operator to convert a Set to an array has some advantages:
	* It's concise and easy to read.
	* It creates a new array with all elements from the Set, which can be beneficial for performance if you need to perform further operations on the array.
However, it also creates a new array with duplicated values (if any) and potentially more memory usage than `Array.from()`.
2. **Array.from**: Using `Array.from()` with a Set as its argument has some advantages:
	* It creates an array with unique elements from the Set, which can be beneficial for performance if you need to process an array with distinct values.
	* It's likely to be more memory-efficient than using the spread operator.
However, it may require more computational resources to create a new array.

**Considerations**

When deciding between these two approaches, consider the following factors:

* Performance: If you need to process an array with unique elements or need better performance for certain operations, `Array.from()` might be a better choice. Otherwise, the spread operator might be sufficient.
* Code readability and conciseness: The spread operator is often more readable and concise in this context.

**Other Alternatives**

In addition to these two approaches, there are other ways to convert an array to a Set or vice versa:

* Using `Set.from()` (ECMAScript 2022): This method creates a new Set from an iterable object.
* Using `Object.keys()` and then creating a Set: You can use `Object.keys()` to get an array of key names from an object (which is essentially equivalent to an array) and then create a Set from that array.

These alternatives might be relevant in specific scenarios, but they are not directly comparable to the spread operator and `Array.from()` approaches used in this benchmark.

Related benchmarks:

array.from vs spread with set (version: 0)

Comparing performance of: spread vs Array.from

Created: 4 years ago by: Guest

Jump to the latest result

spread

Array.from

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