Benchmark: Add element at index 0 (Splice vs Spread vs unshift)

Tests:

Splice
const testArray = [1, 2, 3, 4, 5, 6, 7]; testArray.splice(0, 0, 10);
Unshift
const testArray = [1, 2, 3, 4, 5, 6, 7]; testArray.unshift(10);
Spread
let testArray = [1, 2, 3, 4, 5, 6, 7]; testArray = [10, ...testArray];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Splice
Unshift
Spread

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark on MeasureThat.net, which compares the performance of three different approaches to add an element at index 0 in an array: `splice`, `unshift`, and `spread`.

**Approaches Compared**

1. **Splice**: This method modifies the original array by removing the first element (at index 0) and then inserting the new element.
2. **Unshift**: This method creates a new array with the new element at the beginning and then assigns it to the original array.
3. **Spread**: This method uses the spread operator (`...`) to create a new array by spreading the existing array and then concatenating the new element.

**Pros and Cons of Each Approach**

* **Splice**:
	+ Pros: Efficient for large arrays, as it only requires updating the length property of the original array.
	+ Cons: May not be suitable for small arrays or edge cases where modifying the array's internal state can lead to performance issues.
* **Unshift**:
	+ Pros: Creates a new array with the desired element at the beginning, which can be useful in certain scenarios.
	+ Cons: Requires creating a new array, which can consume more memory and may have slower execution times compared to `splice`.
* **Spread**:
	+ Pros: Creates a new array without modifying the original array's internal state, making it suitable for arrays with many elements or sensitive data.
	+ Cons: May be slower than `splice` due to the creation of a new array.

**Library and Special JS Feature**

None are explicitly mentioned in this benchmark. However, note that some JavaScript engines may have built-in optimizations or specific implementations for these methods.

**Benchmark Preparation Code**

The provided JSON defines three individual test cases:

1. **Splice**: Removes the first element (at index 0) from the `testArray` and inserts a new element.
2. **Unshift**: Adds a new element at the beginning of the `testArray`.
3. **Spread**: Creates a new array by spreading the existing `testArray` and then concatenating a new element.

**Alternative Approaches**

Other approaches to add an element at index 0 in an array might include:

* Using `concat()` with an array literal: `[...testArray, 10]`
* Using a loop to iterate through the array and push the new element: `for (let i = 0; i < testArray.length; i++) { testArray.push(10); }`
* Using a library like Lodash or Ramda for array manipulation

Keep in mind that these alternative approaches may have different performance characteristics, memory usage, or syntax requirements compared to the methods tested in this benchmark.

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 16_5_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5.1 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 16 on iOS 16.5.1

View result in a separate tab

Test name	Executions per second
Splice	12694501.0 Ops/sec
Unshift	16149980.0 Ops/sec
Spread	363280640.0 Ops/sec

Related benchmarks:

Add element at index 0 (Splice vs Spread vs unshift) (version: 0)

Comparing performance of: Splice vs Unshift vs Spread

Created: one year ago by: Guest

Jump to the latest result

Splice

Unshift

Spread

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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