Benchmark: toSpliced vs Spread

Script Preparation code:

var array = Array.from({ length: 100 }).map((val, i) => i);

Tests:

toSpliced
var newArray = array.toSpliced(0, 0, 99);
Spread
var newArray = [99, ...array]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
toSpliced
Spread

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

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

Browser/OS: Chrome 132 on Windows

View result in a separate tab

Test name	Executions per second
toSpliced	34988224.0 Ops/sec
Spread	5152974.0 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**What is being tested?**

The benchmark measures the performance difference between two approaches for creating a new array by removing elements from an existing array: `Array.prototype.toSpliced()` (if available) and the spread operator (`...`).

**Options compared**

There are two options being compared:

1. **`toSpliced()`**: This is a method in the Array prototype that creates a new array with the specified range of elements removed from the original array. It's called `toSpliced()` instead of `splice()`, which is the more traditional way to remove elements from an array.
2. **Spread operator (`...`)**: This is a feature introduced in ECMAScript 2015 (ES6) that allows creating a new array by spreading the elements of an existing array.

**Pros and cons**

Here are some pros and cons of each approach:

* `toSpliced()`:
	+ Pros: It's a built-in method, so it's likely to be optimized for performance.
	+ Cons: It may not be supported in older browsers or versions of JavaScript that don't have this feature.
* Spread operator (`...`):
	+ Pros: It's a modern feature that's widely supported in modern browsers and JavaScript engines. It's also more concise and expressive.
	+ Cons: It may not be as performant as `toSpliced()` for large arrays, since it creates a new array by copying all elements.

**Other considerations**

* **Browser support**: The benchmark is running on Chrome 127, which should have good support for both `toSpliced()` and the spread operator. However, if you're targeting older browsers or versions of JavaScript, you may need to use one approach over the other.
* **JavaScript version**: This benchmark assumes ES6 syntax (the spread operator) and modern JavaScript features. If you need to support older versions of JavaScript, you may need to modify the code accordingly.

**Library usage**

There doesn't appear to be any libraries used in this benchmark.

**Special JS feature or syntax**

The benchmark uses a modern JavaScript feature: the spread operator (`...`). This is introduced in ECMAScript 2015 (ES6) and is widely supported in modern browsers and JavaScript engines.

Related benchmarks:

toSpliced vs Spread (version: 0)

Comparing performance of: toSpliced vs Spread

Created: one year ago by: Guest

Jump to the latest result

toSpliced

Spread

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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