Benchmark: Array.from vs. ... expansion

Script Preparation code:

var set = new Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20])

Tests:

Array.from
var arr = Array.from(set)
... expansion
var arr = [...set]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.from
... expansion

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Overview**

The benchmark measures the performance of two approaches to create an array from a Set object in JavaScript: using the `Array.from()` method and the spread operator (`...`).

**What is being tested?**

* Two test cases are compared:
	+ Test Case 1: Using `Array.from(set)`, where `set` is a Set object created with a large number of elements.
	+ Test Case 2: Using the spread operator (`arr = [...set]`), which expands the Set object into an array.

**Options compared**

The benchmark compares two options:

1. **Using `Array.from()`**: This method creates a new array from an iterable (in this case, the Set object). It's a built-in JavaScript method that provides a concise way to create arrays.
2. **Spread operator (`...`)**: This operator allows you to expand an iterable into an array. In this case, it expands the Set object.

**Pros and Cons**

* Using `Array.from()`:
	+ Pros:
		- Concise and readable syntax
		- Well-documented and widely supported
		- Can handle non-array iterables (like Sets) with ease
	+ Cons:
		- May have performance overhead due to the creation of a new array
* Using the spread operator (`...`):
	+ Pros:
		- Lightweight and efficient, as it only creates an array from the Set object without additional processing
	+ Cons:
		- Less readable and concise syntax compared to `Array.from()`
		- May not be well-documented or widely supported in all browsers

**Library usage**

In this benchmark, no external libraries are used. The Set object is a built-in JavaScript data structure.

**Special JS feature or syntax**

There is no special JavaScript feature or syntax mentioned in the provided benchmark. Both `Array.from()` and the spread operator (`...`) are standard JavaScript features.

**Alternative approaches**

Other alternatives to create an array from a Set object might include:

* Using `set.entries()` to convert the Set object into an iterator, followed by `Array.from()`
* Using `Object.values()` or other methods to extract values from the Set object and then creating an array

However, these alternatives are not tested in this benchmark.

**Benchmark preparation code**

The script preparation code creates a large Set object with 20 elements:
```javascript
var set = new Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]);
```
This code is executed before each test case to ensure that the Set object has a consistent size and content.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.82 Safari/537.36

Browser/OS: Chrome 99 on Windows

View result in a separate tab

Test name	Executions per second
Array.from	3290987.2 Ops/sec
... expansion	6608827.0 Ops/sec

Related benchmarks:

Array.from vs. ... expansion (version: 0)

Comparing performance of: Array.from vs ... expansion

Created: 2 years ago by: Guest

Jump to the latest result

Array.from

... expansion

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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