Benchmark: Spread vs Array.from performance

Tests:

Spread
[...new Array(10)].map(() => (Math.trunc(Math.random() * 36)).toString(36)).join('');
Array.from
Array.from({ length: 10 }, () => (Math.trunc(Math.random() * 36)).toString(36)).join('');
Spread (more elements)
[...new Array(10000)].map(() => (Math.trunc(Math.random() * 36)).toString(36)).join('');
Array.from (more elements)
Array.from({ length: 10000 }, () => (Math.trunc(Math.random() * 36)).toString(36)).join('');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Spread
Array.from
Spread (more elements)
Array.from (more elements)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:137.0) Gecko/20100101 Firefox/137.0

Browser/OS: Firefox 137 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Spread	5663918.5 Ops/sec
Array.from	7661580.5 Ops/sec
Spread (more elements)	5574.2 Ops/sec
Array.from (more elements)	8117.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what is tested, compared, and their pros and cons.

**Benchmark Definition**

The `Benchmark Definition` json represents the code that will be executed to measure performance. In this case, it's a comparison between using the spread operator (`...`) and `Array.from()` to generate a base64-encoded string.

**Options Compared**

Two options are being compared:

1. **Spread Operator (`...`)**: This method uses the spread operator to create an array from an existing array or iterable. In this case, it's used to convert an array of random numbers to base64-encoded strings.
2. **Array.from()**: This method creates a new array instance from an iterable (such as an array or string) and returns it.

**Pros and Cons**

* **Spread Operator (`...`)**:
	+ Pros: It can be more concise and readable for simple cases, especially when working with arrays of small sizes.
	+ Cons: Performance may suffer for large datasets, as it involves creating a new array and iterating over its elements.
* **Array.from()**:
	+ Pros: It provides better performance for large datasets, as it avoids the overhead of creating a new array and iterates directly on the original iterable.
	+ Cons: It can be less readable and more verbose in simple cases.

**Other Considerations**

* Both methods create a new string by concatenating the base64-encoded strings together. This may affect performance if the resulting strings are very large.
* The `Array.from()` method provides more flexibility, as it allows for different types of iterables (e.g., arrays, strings).

**Library and Purpose**

There is no specific library mentioned in the provided JSON.

**Special JS Feature or Syntax**

None.

**Alternatives**

If you want to test alternative approaches, you could consider using other methods such as:

* Using `String.fromCharCode()` instead of `toString()`
* Using `Buffer.concat()` instead of concatenating strings
* Using a different base64 encoding algorithm

Keep in mind that these alternatives may have different performance characteristics and trade-offs.

**Benchmark Preparation Code**

The provided JSON doesn't contain any preparation code, which means that the benchmark will start executing as soon as it's run. If you want to customize the preparation code, you would need to modify the `Script Preparation Code` field in the Benchmark Definition json.

I hope this explanation helps!

Related benchmarks:

Spread vs Array.from performance (version: 0)

Comparing performance of: Spread vs Array.from vs Spread (more elements) vs Array.from (more elements)

Created: 3 years ago by: Guest

Jump to the latest result

Spread

Array.from

Spread (more elements)

Array.from (more elements)

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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