Benchmark: slice VS splice VS shift: who is the fastest to keep constant size

Script Preparation code:

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

Tests:

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

Historical Performance Data aggregated from 384 community runs

Desktop Results:

Chrome 285 runs

splice

4K/s

shift

2K/s

slice

208/s

Fastest: splice (19.4x faster)

View exact numbers

✓ splice: 4,034 ops/sec
• shift: 1,661 ops/sec
• slice: 208 ops/sec

Firefox 62 runs

splice

2.7M/s

shift

1.9M/s

slice

299/s

Fastest: splice (8880.9x faster)

View exact numbers

✓ splice: 2,653,516 ops/sec
• shift: 1,868,053 ops/sec
• slice: 299 ops/sec

Safari 11 runs

shift

11.8M/s

splice

11.7M/s

slice

461/s

Fastest: shift (25677.1x faster)

View exact numbers

✓ shift: 11,843,115 ops/sec
• splice: 11,664,686 ops/sec
• slice: 461 ops/sec

Other 6 runs

splice

4K/s

shift

2K/s

slice

147/s

Fastest: splice (25.6x faster)

View exact numbers

✓ splice: 3,759 ops/sec
• shift: 1,585 ops/sec
• slice: 147 ops/sec

Mobile Results:

Chrome 13 runs

splice

3K/s

shift

1K/s

slice

109/s

Fastest: splice (30.1x faster)

View exact numbers

✓ splice: 3,279 ops/sec
• shift: 1,179 ops/sec
• slice: 109 ops/sec

Safari 7 runs

shift

11.4M/s

splice

9.7M/s

slice

413/s

Fastest: shift (27643.8x faster)

View exact numbers

✓ shift: 11,430,700 ops/sec
• splice: 9,737,960 ops/sec
• slice: 413 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: one month ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 150 on Android

View result in a separate tab

splice

8K/s

shift

1K/s

slice

432/s

View exact numbers

Test name	Executions per second
✓ splice	8,061 Ops/sec
shift	1,358 Ops/sec
slice	432 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net!

**Benchmark Definition**

The benchmark definition represents a JavaScript code snippet that is used to test the performance of different approaches. In this case, we have three benchmark definitions:

1. `list.push('slice');\nlist = list.slice(1);` (Slice)
2. `list.push('splice');\nlist.splice(0, 1);` (Splice)
3. `list.push('splice');\nlist.shift();` (Shift)

Each benchmark definition is a JavaScript code snippet that pushes an element to the end of the array `list`, and then either uses `slice()` or `splice()`/`shift()` to modify the array.

**Options Compared**

The options being compared are:

* **Slice**: The `slice()` method creates a shallow copy of a portion of an array.
	+ Pros: Creates a new array, doesn't mutate the original array.
	+ Cons: Can be slower due to the creation of a new array.
* **Splice**: The `splice()` method modifies the array by removing or replacing elements.
	+ Pros: Modifies the original array, can be faster than `slice()`.
	+ Cons: Mutates the original array, can have unexpected side effects.
* **Shift**: The `shift()` method removes and returns the first element of an array.
	+ Pros: Modifies the original array, can be fast due to the removal of an element at the beginning.
	+ Cons: Only works on arrays with more than one element.

**Library**

The library used in these benchmark definitions is none. The tests use built-in JavaScript methods (`slice()`, `splice()`, and `shift()`).

**Special JS Feature/Syntax**

There are no special JavaScript features or syntaxes being tested in this benchmark. The tests only rely on standard JavaScript methods and built-in types.

**Other Alternatives**

If you're looking for alternatives to these approaches, consider:

* **Array.prototype.slice.call()**: Creates a new array from an existing one.
* **Array.prototype.splice() with start and end indices**: Modifies the original array by removing or replacing elements at specific positions.
* **Array.prototype.shift()** (same as above): Removes and returns the first element of an array.

These alternatives can be used in similar scenarios, but their performance characteristics might differ from the ones tested here.

slice VS splice VS shift: who is the fastest to keep constant size (version: 0) Benchmark.js

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: 8 years ago by: Guest

Go to the latest result

slice

splice

shift

Historical Performance Data aggregated from 384 community runs

Desktop Results:

Chrome 285 runs

Firefox 62 runs

Safari 11 runs

Other 6 runs

Mobile Results:

Chrome 13 runs

Safari 7 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

slice VS splice VS shift: who is the fastest to keep constant size (version: 0) Benchmark.js

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: 8 years ago by: Guest

Go to the latest result

slice

splice

shift

Historical Performance Data aggregated from 384 community runs

Desktop Results:

Chrome 285 runs

Firefox 62 runs

Safari 11 runs

Other 6 runs

Mobile Results:

Chrome 13 runs

Safari 7 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `slice vs splice vs shift`