Benchmark: Remove element from array

Script Preparation code:

var arr = [];
for (var i = 0; i < 10000; i++) {
  arr.push(Math.floor(Math.random() * 1000) + 1)
}
arr.splice(5000, 0, 0)

Tests:

filter (immutable)
var tempResult = arr.filter(v => v !== 0);
indexOf and delete (will leave initial length of array) (mutable)
var index = arr.indexOf(0); delete arr[index]; var tempResult = arr;
indexOf and splice (mutable)
var index = arr.indexOf(0); arr.splice(index, 1); var tempResult = arr;
indexOf and slice and spread (immutable)
var index = arr.indexOf(0); var tempResult = [...arr.slice(0, index - 1), ...arr.slice(index+1)]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
filter (immutable)
indexOf and delete (will leave initial length of array) (mutable)
indexOf and splice (mutable)
indexOf and slice and spread (immutable)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36

Browser/OS: Chrome 104 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
filter (immutable)	22913.3 Ops/sec
indexOf and delete (will leave initial length of array) (mutable)	830730.8 Ops/sec
indexOf and splice (mutable)	7961174.5 Ops/sec
indexOf and slice and spread (immutable)	7081080.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided benchmark is designed to test the performance of JavaScript arrays in different scenarios: removing an element from an array.

**Options Compared**

There are four options being compared:

1. **Filter (immutable)**: Creating a new array using `filter()` method without modifying the original array.
2. **IndexOf and Delete (mutable)**: Finding the index of the target element using `indexOf()`, deleting it, and then creating a new array by removing the deleted element from the end of the original array.
3. **IndexOf and Splice (mutable)**: Finding the index of the target element using `indexOf()`, splicing the element at that index to create a new array with the same length as the original array, but without modifying the original array.
4. **IndexOf and Slice and Spread (immutable)**: Creating a new array by concatenating two arrays created using `slice()` method.

**Pros and Cons**

1. **Filter (immutable)**:
	* Pros: Creates a new array without modifying the original array, which can be more efficient for large datasets. It's also a concise and expressive way to filter an array.
	* Cons: May not be as efficient as other methods if the filtering condition is complex or involves multiple operations.
2. **IndexOf and Delete (mutable)**:
	* Pros: Can be faster than `filter()` method because it avoids creating a new array, but may require more memory allocation and deallocation due to the deletion operation.
	* Cons: Deletes an element from the original array, which can lead to performance issues if the array is large or frequently modified.
3. **IndexOf and Splice (mutable)**:
	* Pros: Avoids modifying the original array by using `splice()` method, but may still incur a performance penalty due to the indexing operation.
	* Cons: Requires an extra step to update the index of the remaining elements in the array after splicing.
4. **IndexOf and Slice and Spread (immutable)**:
	* Pros: Creates a new array without modifying the original array by using `slice()` method, which can be more efficient than other methods for large datasets.
	* Cons: May require more memory allocation due to the creation of two intermediate arrays.

**Library Usage**

The benchmark uses no external libraries, relying solely on the built-in JavaScript features.

**Special JS Features or Syntax**

There are a few special JS features used in this benchmark:

1. **Arrow functions**: Used in the `filter()` method to define the filtering condition.
2. **Template literals**: Used to concatenate strings and numbers in some test cases.
3. **Destructuring assignment**: Not explicitly used, but implicit in the `slice()` method calls.

**Alternatives**

Other alternatives for removing elements from an array include:

1. **Array methods like `map()`, `forEach()`, or `every()``**: These can be used to filter or remove elements from an array without modifying it, similar to the `filter()` method.
2. **Using a `for...of` loop**: This can be used to iterate over the array and remove elements directly, but may require more manual memory management.

Note that the choice of approach depends on the specific use case, performance requirements, and personal preference.

Related benchmarks:

Remove element from array (version: 0)

Comparing performance of: filter (immutable) vs indexOf and delete (will leave initial length of array) (mutable) vs indexOf and splice (mutable) vs indexOf and slice and spread (immutable)

Created: 2 years ago by: Guest

Jump to the latest result

filter (immutable)

indexOf and delete (will leave initial length of array) (mutable)

indexOf and splice (mutable)

indexOf and slice and spread (immutable)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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