Benchmark: Array.from vs Spread multiple count sizes

Tests:

Array.from 20
var fooSet = new Set(); for(var i=0;i<20;i++) { fooSet.add(i); } var other = Array.from(fooSet);
Spread 20
var fooSet = new Set(); for(var i=0;i<20;i++) { fooSet.add(i); } var other = [...fooSet];
Array.from 100
var fooSet = new Set(); for(var i=0;i<100;i++) { fooSet.add(i); } var other = Array.from(fooSet);
Spread 100
var fooSet = new Set(); for(var i=0;i<100;i++) { fooSet.add(i); } var other = [...fooSet];
Array.from 1000
var fooSet = new Set(); for(var i=0;i<1000;i++) { fooSet.add(i); } var other = Array.from(fooSet);
Spread 1000
var fooSet = new Set(); for(var i=0;i<1000;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 20
Spread 20
Array.from 100
Spread 100
Array.from 1000
Spread 1000

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 114 on Linux

View result in a separate tab

Test name	Executions per second
Array.from 20	948334.4 Ops/sec
Spread 20	1125966.9 Ops/sec
Array.from 100	308981.0 Ops/sec
Spread 100	310785.2 Ops/sec
Array.from 1000	30765.4 Ops/sec
Spread 1000	31345.8 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Overview**

The benchmark is designed to compare the performance of two approaches: using `Array.from()` with a `Set` object, and using the spread operator (`...`) with a `Set` object. The benchmark tests these two approaches for different sizes of data (20, 100, and 1000 elements).

**What's being tested**

The test cases are designed to measure the performance of:

1. Converting a `Set` object to an array using `Array.from()`.
2. Using the spread operator (`...`) to create a new array from a `Set` object.

**Options compared**

Two options are compared:

A) `Array.from()` with a `Set` object
B) Spread operator (`...`) with a `Set` object

**Pros and Cons of each approach**

1. **`Array.from()` with a `Set` object**:
	* Pros: This method is more explicit, as it clearly states the intention to convert a `Set` to an array.
	* Cons: It may have performance overhead due to the additional function call.
2. **Spread operator (`...`) with a `Set` object**:
	* Pros: This method is often considered more concise and readable, as it uses a familiar syntax for creating arrays.
	* Cons: The spread operator can be slower than calling `Array.from()` explicitly.

**Library used**

The benchmark uses the built-in `Set` and `Array` objects in JavaScript. These are standard library functions that provide a way to work with sets and arrays in JavaScript.

**Special JS feature or syntax**

This benchmark does not use any special JavaScript features or syntax beyond what is standard for modern JavaScript environments.

**Other considerations**

1. **Browser differences**: The benchmark results show variations between different browser versions (Chrome 114) on the same device (Desktop, Linux). This highlights the importance of considering browser differences when writing benchmarks.
2. **Platform and OS differences**: Although not explicitly mentioned in the provided data, it's essential to note that the test may also be affected by platform and OS differences, which can impact performance.

**Alternative approaches**

Other approaches that could be used to compare these two methods include:

1. Using a different library or implementation (e.g., Lodash, Ramda) for set-to-array conversion.
2. Implementing custom set-to-array conversion logic using a loop or recursion.
3. Adding more data sizes and browser versions to the benchmark to increase its sample size and statistical power.

Keep in mind that these alternatives may not directly compare the performance of `Array.from()` versus the spread operator, as they introduce additional variations in the benchmark setup.

Related benchmarks:

Array.from vs Spread multiple count sizes (version: 0)

Comparing performance of: Array.from 20 vs Spread 20 vs Array.from 100 vs Spread 100 vs Array.from 1000 vs Spread 1000

Created: one year ago by: Guest

Jump to the latest result

Array.from 20

Spread 20

Array.from 100

Spread 100

Array.from 1000

Spread 1000

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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