Benchmark: slice VS splice VS shift VS length adjust: 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();
length adjust
list.push('length adjust'); list.length = list.length - 1;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
slice
splice
shift
length adjust

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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.

**Benchmark Overview**

The provided benchmark compares four different approaches to adjust the length of an array in JavaScript:

1. `slice()`
2. `splice()`
3. `shift()`
4. Manual length adjustment (`list.length = list.length - 1`)

**Options Compared**

* `slice()`: creates a new array by copying a section of the original array.
	+ Pros: efficient, predictable performance, no mutation of the original array.
	+ Cons: creates a new object in memory, which can be slower for large arrays.
* `splice()`: modifies the original array by removing elements from a specified position.
	+ Pros: modifies the original array in-place, which can be faster for large arrays.
	+ Cons: mutation of the original array, unpredictable performance due to garbage collection.
* `shift()`: removes the first element from the end of the array and returns it.
	+ Pros: efficient, predictable performance, no mutation of the original array (except for the first element).
	+ Cons: only modifies the first element, which can be slower than other approaches for large arrays.
* Manual length adjustment (`list.length = list.length - 1`): directly adjusts the length property of the array.
	+ Pros: fast, no additional memory allocation or mutation required.
	+ Cons: can lead to performance issues due to garbage collection or caching effects.

**Library Used**

There is no library explicitly used in this benchmark. However, it's worth noting that `slice()` and `splice()` are built-in methods in JavaScript, while `shift()` is also a native method.

**Special JS Features or Syntax**

None of the approaches mentioned require any special JavaScript features or syntax beyond standard ECMAScript 2022.

**Benchmark Results**

The latest benchmark results show that:

* Manual length adjustment (`length adjust`) is the fastest approach.
* `splice()` is significantly slower than the other three approaches due to its mutation of the original array and unpredictable performance.
* `shift()` is faster than `slice()`, but still slower than manual length adjustment.
* `slice()` is the slowest approach, likely due to the additional memory allocation required for creating a new array.

**Other Alternatives**

Some alternative approaches that could be tested in this benchmark include:

* Using a library like Lodash's `removeAt()` method
* Utilizing WebAssembly or other just-in-time (JIT) compilation techniques to optimize performance
* Implementing a custom, optimized implementation of the four approaches using native code or WebAssembly

However, these alternatives are likely to be more complex and may not offer significant performance improvements over the existing benchmark results.

Related benchmarks:

slice VS splice VS shift VS length adjust: who is the fastest to keep constant size (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 vs length adjust

Created: 4 years ago by: Guest

Jump to the latest result

slice

splice

shift

length adjust

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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