Benchmark: add many elements to beginning of array: unshift vs splice vs push+sort

Script Preparation code:

var data = [];
for (let i = 0; i < 10000; ++i) data[i] = i;
var add = [];
for (let i = -100; i < -1; ++i) add[i] = i;

Tests:

unshift
data.unshift(...add);
splice
data.splice(0, 0, ...add)
push+sort
data.push(...add); data.sort((a,b)=>a-b);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
unshift
splice
push+sort

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 break down the provided benchmark and its test cases.

**What is being tested?**

The benchmark is testing three different approaches to add elements to the beginning of an array in JavaScript: `unshift`, `splice`, and `push` followed by sorting. The goal is to determine which approach is the most efficient.

**Options compared**

*   `unshift`: Adds one or more elements to the beginning of an array.
*   `splice`: Removes elements from a specific index and adds new elements to that position.
*   `push+sort`: Adds elements to the end of the array using `push` and then sorts the entire array.

**Pros and Cons**

*   **unshift**: Pros:
    *   More efficient than `splice` for adding elements to the beginning, as it only modifies a single element in the array.
    *   Can be faster for large arrays because it doesn't require shifting all existing elements down.
*   Cons:
    *   Can be slower if the array is already full, since it has to resize the array internally.
*   **splice**: Pros:
    *   Faster than `unshift` when adding many elements and resizing the array.
    *   Allows for more flexibility in terms of inserting or removing elements at specific indices.
*   Cons:
    *   Slower than `unshift` for adding elements to the beginning, since it has to shift all existing elements down.
    *   Requires specifying the index where new elements should be inserted.
*   **push+sort**: Pros:
    *   Simple and easy to implement.
*   Cons:
    *   Inefficient for large arrays because sorting has a time complexity of O(n log n).
    *   Creates a copy of the array, which can lead to increased memory usage.

**Library/Utilities used**

In this benchmark, no specific libraries or utilities are explicitly mentioned. However, it's worth noting that some JavaScript implementations might have built-in optimizations for certain operations, such as `push` or `splice`, depending on the engine and version.

**Special JS feature/Syntax (None)**

There is no special JavaScript feature or syntax being tested in this benchmark.

**Alternative approaches**

Some alternative approaches to adding elements to an array include:

*   Using `Array.prototype.reduce()` or a similar method to concatenate arrays.
*   Using a loop with a `for...of` loop and `push` or `unshift`.
*   Using `Array.prototype.concat()` followed by `sort`.

Keep in mind that the performance of these alternatives might be different from the three approaches being tested, depending on the specific requirements and constraints of your use case.

**Benchmark Preparation Code**

The provided preparation code creates two arrays:

*   A large array `data` with 10,000 elements, starting from index -100 to 0.
*   An empty array `add` also with 10,000 elements, but this time from index -100 to 1.

Related benchmarks:

add many elements to beginning of array: unshift vs splice vs push+sort (version: 0)

Comparing performance of: unshift vs splice vs push+sort

Created: 2 years ago by: Guest

Jump to the latest result

unshift

splice

push+sort

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