Benchmark: Remove item from array by index (with Shift)

Tests:

Splice
const a = ["a", "b", "c", "d", "e"]; const indexToRemove = 2; const b = a.splice(indexToRemove, 1);
Slice using spread uperator
const a = ["a", "b", "c", "d", "e"]; const indexToRemove = 2; const b = [...a.slice(0, indexToRemove), ...a.slice(indexToRemove + 1)];
Slice using concat
const a = ["a", "b", "c", "d", "e"]; const indexToRemove = 2; const b = a.slice(0, indexToRemove).concat(a.slice(indexToRemove + 1));
Filter
const a = ["a", "b", "c", "d", "e"]; const indexToRemove = 2; const b = a.filter((_, i) => i !== indexToRemove)
Shift
const a = ["a", "b", "c", "d", "e"]; const b = a.shift()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Splice
Slice using spread uperator
Slice using concat
Filter
Shift

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what is being tested, the options compared, pros and cons of each approach, and other considerations.

**Benchmark Definition**

The benchmark definition provides a clear description of the test case:

* Remove item from array by index (with Shift)
* The script preparation code is empty, which means the test will start with an empty array.
* The HTML preparation code is also empty, indicating that no initial HTML setup is required for this test.

**Test Cases**

The benchmark includes four individual test cases, each representing a different approach to remove an item from an array:

1. **Splice**: Uses the `splice()` method to remove and return elements from an array.
2. **Slice using spread operator**: Uses the spread operator (`...`) to create a new array with the desired elements.
3. **Slice using concat**: Uses the `concat()` method to concatenate two arrays, effectively removing the unwanted element.
4. **Filter**: Uses the `filter()` method to remove elements from an array based on a callback function.

**Pros and Cons of each approach**

* **Splice**: Pros:
	+ Efficient for large arrays
	+ Returns the removed element(s)
	Cons:
	+ Can be slower than other approaches for small arrays due to the overhead of removing elements.
* **Slice using spread operator**: Pros:
	+ Fast and efficient, even for large arrays
	+ Creates a new array, leaving the original unchanged
	Cons:
	+ Requires modern JavaScript support (ES6+)
	+ Can be slower than other approaches if the resulting array is very large.
* **Slice using concat**: Pros:
	+ Simple and straightforward implementation
	+ Works with older JavaScript versions
	Cons:
	+ Can be slower than other approaches due to the overhead of concatenation.
	+ Returns a new array, which may not be desirable for all use cases.
* **Filter**: Pros:
	+ Fast and efficient, even for large arrays
	+ Does not require creating a new array, reducing memory usage
	Cons:
	+ Requires a callback function, which can add overhead

**Library Used**

None of the test cases use any libraries. The `splice()`, `slice()`, `concat()`, and `filter()` methods are all built-in JavaScript methods.

**Special JS Feature or Syntax**

None of the test cases use any special JavaScript features or syntax beyond what is standard in modern JavaScript (ES6+). However, it's worth noting that the spread operator (`...`) is a relatively new feature introduced in ES6, which may affect the compatibility of these tests with older JavaScript versions.

**Alternatives**

For removing elements from an array, other alternatives include:

* Using `Array.prototype.reduce()` to accumulate elements into a new array
* Using `Array.prototype.map()` and `Array.prototype.filter()` together to create a new array
* Using a for loop to iterate over the array and add or remove elements

However, these approaches may have different performance characteristics and use cases compared to the methods tested in this benchmark.

Latest run results:

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

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

Browser/OS: Chrome Mobile 117 on Android

View result in a separate tab

Test name	Executions per second
Splice	1121756.9 Ops/sec
Slice using spread uperator	992925.1 Ops/sec
Slice using concat	570426.5 Ops/sec
Filter	3882650.0 Ops/sec
Shift	4597554.0 Ops/sec

Related benchmarks:

Remove item from array by index (with Shift) (version: 0)

Comparing performance of: Splice vs Slice using spread uperator vs Slice using concat vs Filter vs Shift

Created: one year ago by: Registered User

Jump to the latest result

Splice

Slice using spread uperator

Slice using concat

Filter

Shift

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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