Benchmark: Array.apply vs Spread new array

Tests:

Array.apply (small)
const array = Array.apply(null, {length: 5});
Spread new Array (small)
const array = [...Array(5)]
Array.apply (big)
const array = Array.apply(null, {length: 100000});
Spread new Array (big)
const array = [...Array(100000)]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.apply (small)
Spread new Array (small)
Array.apply (big)
Spread new Array (big)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:100.0) Gecko/20100101 Firefox/100.0

Browser/OS: Firefox 100 on Linux

View result in a separate tab

Test name	Executions per second
Array.apply (small)	3603345.2 Ops/sec
Spread new Array (small)	9824382.0 Ops/sec
Array.apply (big)	317.9 Ops/sec
Spread new Array (big)	546.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what is tested in the provided JSON and explain the options, pros, cons, and other considerations.

**Benchmark Definition**

The benchmark measures the performance difference between using `Array.apply()` and the spread operator (`...`) to create a new array of a specified length.

**Options Compared**

There are two main options compared:

1. **`Array.apply(null, {length: 5})`**: This method uses the `apply()` method on an empty function object (due to `null` being used as the first argument) to specify the length of the new array.
2. **`[...Array(5)]`** or **`const array = Array.from(Array(5))`**: These methods use the spread operator (`...`) to create a new array from an existing one.

**Pros and Cons**

1. `Array.apply(null, {length: 5})`:
	* Pros: This method is more explicit and can be easier to read for those familiar with it.
	* Cons: It's less efficient than the spread operator due to the overhead of creating a function object.
2. `[...Array(5)]` or `const array = Array.from(Array(5))`:
	* Pros: These methods are more concise and efficient, as they directly create an array using the spread operator.
	* Cons: They can be less readable for those not familiar with them.

**Library Used**

None. The benchmark only uses native JavaScript features.

**Special JS Feature or Syntax**

The `Spread Operator` (`...`) is used in two of the test cases. It's a relatively recent feature introduced in ECMAScript 2015 (ES6). The spread operator allows for spreading the elements of an array into a new array, and it's often used to create a shallow copy of an existing array.

**Other Considerations**

* **Cache locality**: When using `Array.apply()`, the function object is created, which can lead to cache locality issues. In contrast, the spread operator creates a new array without creating a separate function object.
* **Function creation overhead**: The `apply()` method involves creating a function object and passing it as an argument, whereas the spread operator directly creates an array.

**Alternatives**

If you were to rewrite this benchmark using different approaches, some alternatives could be:

1. Using `Array.from()` with no arguments (e.g., `Array.from()`) instead of `[...Array(5)]` or `const array = Array.from(Array(5))`.
2. Using a custom function to create an array (e.g., `function createArray(length) { ... }`).
3. Measuring the performance of other methods, such as using `Map` or `Set` instead of arrays.

However, these alternatives would likely change the nature of the benchmark and might not provide comparable results to the original spread operator vs. `Array.apply()` comparison.

Related benchmarks:

Array.apply vs Spread new array (version: 0)

Comparing performance of: Array.apply (small) vs Spread new Array (small) vs Array.apply (big) vs Spread new Array (big)

Created: 7 years ago by: Guest

Jump to the latest result

Array.apply (small)

Spread new Array (small)

Array.apply (big)

Spread new Array (big)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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