Benchmark: slice VS splice VS shift: who is the fastest to keep constant size (fork no string push)

Script Preparation code:

var list = [];
for (var i = 0; i < 1000 * 1000; i++) {
  list.push(i);
}

Tests:

slice
list = list.slice(1);
splice
list.splice(0, 1);
shift
list.shift();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
slice
splice
shift

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 132 on Ubuntu

View result in a separate tab

Test name	Executions per second
slice	164.0 Ops/sec
splice	29070012.0 Ops/sec
shift	173746016.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

The provided JSON represents a benchmark test case on MeasureThat.net, which compares the performance of three different approaches to remove elements from an array: `splice`, `shift`, and `slice`. The test aims to determine who is the fastest to modify the size of an array without pushing or shifting strings onto it.

**Benchmark Definition**

The original JSON defines a single benchmark case:

`"Name": "slice VS splice VS shift: who is the fastest to keep constant size (fork no string push)"`

This name gives us an idea of what's being tested: three different array manipulation methods and their performance when modifying the array's length without adding or removing strings.

**Benchmark Preparation Code**

The preparation code for this benchmark:

`var list = [];`
`for (var i = 0; i < 1000 * 1000; i++) {`
`  list.push(i);`
`}`

This code creates an array `list` with 1,000,000 elements and initializes it with integers from 0 to 999,999. This is done to ensure that the benchmark tests are run on a large enough dataset.

**Options Compared**

The three options being compared in this test case are:

1. **Slice**: The `slice()` method returns a shallow copy of a portion of an array. In this test, it's used to remove the first element from the array (`list.slice(1)`).
2. **Splice**: The `splice()` method removes elements from an array and returns the removed elements. It's used to remove the first element from the array (`list.splice(0, 1)`).
3. **Shift**: The `shift()` method removes the first element from an array and returns it. It's used to remove the first element from the array (`list.shift()`).

**Pros and Cons of Each Approach**

*   **Slice**: Creates a new copy of the array, which can be memory-intensive for large datasets.
    *   Pros: Fast execution time since it doesn't modify the original array.
    *   Cons: Can lead to higher memory usage due to creating an additional copy.
*   **Splice**: Modifies the original array and returns the removed elements. It's more efficient than `slice()` but can be slower than `shift()`.
    *   Pros: More efficient than `slice()` since it doesn't create a new copy.
    *   Cons: May be slower than `shift()` due to modifying the original array.
*   **Shift**: Removes the first element from the array without creating a new one. It's often faster than `splice()` and `slice()` for removing elements at the beginning of an array.
    *   Pros: Fast execution time since it only modifies the first element.
    *   Cons: May be slower than `splice()` if the removed element is not at the beginning.

**Library Usage**

In this benchmark, no external libraries are used. The code relies solely on built-in JavaScript methods.

**Special JS Features or Syntax**

None of the tested features require special syntax or advanced JavaScript features beyond basic array manipulation techniques.

**Other Alternatives**

For similar use cases:

*   **Array.prototype.at()**: A more modern approach to accessing elements at specific indices, which can be faster than `slice()` and `shift()`.
*   **Array.prototype.slice.call()**: An alternative way to call the `slice()` method on an array using the `call()` method.
*   **Array.prototype.concat()**: Can be used with `splice()` or `shift()` methods for more complex array manipulations.

For testing and benchmarking, MeasureThat.net provides a unique platform that allows users to compare performance of different JavaScript code snippets. By comparing the execution times of various methods, developers can make informed decisions about which approach to use in their own projects.

Related benchmarks:

slice VS splice VS shift: who is the fastest to keep constant size (fork no string push) (version: 0)

100k list splice and shift win, they mutate list slice loose, it creates a copy of list 7.5x slower

Comparing performance of: slice vs splice vs shift

Created: 2 years ago by: Registered User

Jump to the latest result

slice

splice

shift

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):