Benchmark: Array indexOf and splice vs Set delete

Script Preparation code:

function arrayWithLength(length) {
    return Array(length).fill().map((_, i) => i);
}
var arr10 = arrayWithLength(10);
var arr30 = arrayWithLength(30);
var arr100 = arrayWithLength(100);
var set10 = new Set(arr10);
var set30 = new Set(arr30);
var set100 = new Set(arr100);

Tests:

indexOf arr10
const i = arr10.indexOf(9); arr10.splice(i, 1)
delete set10
set10.delete(9);
indexOf arr30
const i = arr10.indexOf(29); arr10.splice(i, 1)
delete set30
set10.delete(29);
indexOf arr99
const i = arr10.indexOf(99); arr10.splice(i, 1)
delete set100
set10.delete(99);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf arr10
delete set10
indexOf arr30
delete set30
indexOf arr99
delete set100

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON and explain what's being tested.

**Benchmark Definition**

The benchmark is measuring the performance difference between using `Array.prototype.indexOf()` and `splice()` for removing elements, compared to using a `Set` data structure for similar operations. The script creates three arrays of different lengths (10, 30, and 100) and three sets from these arrays.

**Options being compared**

There are two main options being compared:

1. **Array.prototype.indexOf() + Array.prototype.splice()**: This approach uses the `indexOf()` method to find the index of the element to be removed, and then uses the `splice()` method to remove the element at that index.
2. **Set.delete()**: This approach uses a built-in `Set` data structure, which is designed for fast membership testing and removal of elements.

**Pros and Cons**

* **Array.prototype.indexOf() + Array.prototype.splice()**:
	+ Pros: Simple and widely supported; works well with existing code that uses `indexOf()` and `splice()`.
	+ Cons: Can be slower than using a `Set` data structure, especially for large datasets.
* **Set.delete()**:
	+ Pros: Fast and efficient, especially for membership testing and removal of elements. Sets are designed to eliminate duplicates and provide fast lookups.
	+ Cons: Requires creating a new set from the array elements (as shown in the script preparation code), which can add overhead.

Other considerations:

* **Array.prototype.indexOf()` is generally slower than `Set.delete()` because it has to iterate through the entire array to find the index, whereas sets use a hash table for fast lookups.
* Using a `Set` data structure can be beneficial when you need to eliminate duplicates or perform fast membership testing.

**Library and purpose**

The `Array.prototype.indexOf()` method is a built-in JavaScript method that returns the index of the first occurrence of a specified value in an array. The `Array.prototype.splice()` method removes elements from an array at a specified position.

**Special JS feature or syntax (none)**

There are no special features or syntax being tested in this benchmark.

**Other alternatives**

Some alternative approaches to using `Set.delete()` include:

* **Using Array.prototype.filter()**: Instead of removing individual elements, you could use `filter()` to create a new array with only the desired elements. This approach can be slower for large datasets.
* **Using a custom data structure**: Depending on your specific use case, you might consider implementing a custom data structure that combines the benefits of arrays and sets.

It's worth noting that MeasureThat.net is designed to provide an objective comparison of different JavaScript implementations and libraries. The benchmark framework allows you to create custom benchmarks like this one to compare the performance of different approaches.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
indexOf arr10	5760873.0 Ops/sec
delete set10	11470537.0 Ops/sec
indexOf arr30	5412749.5 Ops/sec
delete set30	12648791.0 Ops/sec
indexOf arr99	5604304.5 Ops/sec
delete set100	12549561.0 Ops/sec

Related benchmarks:

Array indexOf and splice vs Set delete (version: 0)

Comparing performance of: indexOf arr10 vs delete set10 vs indexOf arr30 vs delete set30 vs indexOf arr99 vs delete set100

Created: one year ago by: Guest

Jump to the latest result

indexOf arr10

delete set10

indexOf arr30

delete set30

indexOf arr99

delete set100

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