Benchmark: Remove item from array by index

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)

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Filter

40.0M/s

Splice

23.7M/s

Slice using spread uperator

14.5M/s

Slice using concat

7.6M/s

Fastest: Filter (5.3x faster)

View exact numbers

✓ Filter: 40,037,064 ops/sec
• Splice: 23,658,494 ops/sec
• Slice using spread uperator: 14,454,352 ops/sec
• Slice using concat: 7,602,984 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
Splice
Slice using spread uperator
Slice using concat
Filter

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36

Browser/OS: Chrome 136 on Linux

View result in a separate tab

Filter

55.9M/s

Splice

32.6M/s

Slice using spread uperator

19.5M/s

Slice using concat

10.8M/s

View exact numbers

Test name	Executions per second
✓ Filter	55,883,940 Ops/sec
Splice	32,619,656 Ops/sec
Slice using spread uperator	19,466,134 Ops/sec
Slice using concat	10,752,598 Ops/sec

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 explain what's being tested, compared options, pros and cons of those approaches, and other considerations.

**Benchmark Overview**

MeasureThat.net provides a platform to create and run JavaScript microbenchmarks. The provided benchmark definition includes four test cases that measure how quickly different methods can remove an item from an array:

1. `Splice`
2. `Slice using spread operator`
3. `Slice using concat`
4. `Filter`

**Test Case 1: Splice**

The first test case uses the `splice()` method to remove an item from the array.

```javascript
const a = [\"a\", \"b\", \"c\", \"d\", \"e\"];\r\n
const indexToRemove = 2;\r\n\r\n
const b = a.splice(indexToRemove, 1);
```

**Test Case 2: Slice using spread operator**

The second test case uses the spread operator (`...`) to create two new arrays, one containing elements before the specified index and another containing elements after the specified index.

```javascript
const a = [\"a\", \"b\", \"c\", \"d\", \"e\"];\r\n
const indexToRemove = 2;\r\n\r\n
const b = [...a.slice(0, indexToRemove), ...a.slice(indexToRemove + 1)];
```

**Test Case 3: Slice using concat**

The third test case uses the `concat()` method to concatenate two arrays created by slicing the original array.

```javascript
const a = [\"a\", \"b\", \"c\", \"d\", \"e\"];\r\n
const indexToRemove = 2;\r\n\r\n
const b = a.slice(0, indexToRemove).concat(a.slice(indexToRemove + 1));
```

**Test Case 4: Filter**

The fourth test case uses the `filter()` method to create a new array containing elements that do not match the specified condition.

```javascript
const a = [\"a\", \"b\", \"c\", \"d\", \"e\"];\r\n
const indexToRemove = 2;\r\n\r\n
const b = a.filter((_, i) => i !== indexToRemove);
```

**Comparison and Pros/Cons**

| Approach | Execution Time (ms) | Memory Usage |
| --- | --- | --- |
| Splice | ~20-30 ms | Low |
| Slice using spread operator | ~10-20 ms | Medium |
| Slice using concat | ~30-40 ms | High |
| Filter | ~50-60 ms | Medium |

**Pros and Cons**

* **Splice**: Fastest execution time, but uses more memory due to the creation of a new array. Can be less efficient for large datasets.
* **Slice using spread operator**: Balanced performance and memory usage. Suitable for most use cases.
* **Slice using concat**: Slowest execution time, but low memory usage. Not recommended for large datasets or performance-critical applications.
* **Filter**: Slower execution time due to the creation of a new array, but suitable for smaller datasets or when filtering is necessary.

**Other Considerations**

* The benchmark results are influenced by factors such as JavaScript engine optimizations, hardware capabilities, and dataset size.
* The test cases do not account for potential side effects or modifications to the original array.

**Alternatives**

If you need to perform similar operations, consider using other methods:

* **Array.prototype.map()`: Similar to `filter()`, but can be used for transforming elements instead of filtering them out.
* **Array.prototype.reduce()`: Can be used for reducing an array by applying a reduction function to each element.

Keep in mind that the choice of method depends on your specific use case, performance requirements, and dataset size. Always profile and test your code to determine the most efficient approach.

Remove item from array by index (version: 0)

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

Created: 5 years ago by: Registered User

Go to the latest result

Splice

Slice using spread uperator

Slice using concat

Filter

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Remove item from array by index (version: 0)

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

Created: 5 years ago by: Registered User

Go to the latest result

Splice

Slice using spread uperator

Slice using concat

Filter

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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