Benchmark: Array indexOf and splice vs Set delete - good

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 = arr30.indexOf(29); arr30.splice(i, 1)
delete set30
set30.delete(29);
indexOf arr100
const i = arr100.indexOf(99); arr100.splice(i, 1)
delete set100
set100.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 arr100
delete set100

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 123 on Windows

View result in a separate tab

Test name	Executions per second
indexOf arr10	9717645.0 Ops/sec
delete set10	18703900.0 Ops/sec
indexOf arr30	9749085.0 Ops/sec
delete set30	19557008.0 Ops/sec
indexOf arr100	9760472.0 Ops/sec
delete set100	19306702.0 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 its test cases.

**Benchmark Overview**

The benchmark measures the performance of JavaScript arrays (`arr10`, `arr30`, `arr100`) with their `splice` and `indexOf` methods, as well as Sets (`set10`, `set30`, `set100`) with their `delete` method. The goal is to determine which approach is faster for each scenario.

**Options Compared**

1. **Array Splice**: Replacing an element in the array.
	* Pros: Can be used for inserting or removing elements from any position in the array.
	* Cons: Has a linear search time complexity (O(n)) because it must find the index of the element to be replaced, and then shift all subsequent elements.
2. **Array IndexOf**: Finding the index of an element in the array.
	* Pros: Can be used for searching elements in the array without having to iterate through its entire length.
	* Cons: Returns -1 if the element is not found, which can lead to additional checks or handling code.
3. **Set Delete**: Removing an element from a Set.
	* Pros: Fast and efficient because Sets use a hash table for storage.
	* Cons: Assumes that the element being deleted exists in the Set.

**Test Cases**

Each test case measures the performance of either `splice` or `indexOf` on an array, followed by deleting an element from a Set. The arrays are created with different lengths (`10`, `30`, and `100`) to simulate varying workloads.

**Library Used (Set)**

The benchmark uses JavaScript's built-in `Set` data structure, which is implemented as a hash table for efficient lookups, insertions, and deletions.

**Special JS Features/Syntax**

None mentioned in the provided code or benchmark definition. However, it's worth noting that the `map` method used in the script preparation code (`arrayWithLength`) is a modern JavaScript feature introduced in ECMAScript 5 (ES5).

**Pros and Cons of Different Approaches**

1. **Array Splice**:
	* Pros: Allows for flexible insertion or removal of elements at any position.
	* Cons: Linear search time complexity, which can be slow for large arrays.
2. **Array IndexOf**:
	* Pros: Fast lookup times, suitable for searching elements without iterating through the entire array.
	* Cons: Returns -1 if the element is not found, leading to additional checks or handling code.
3. **Set Delete**:
	* Pros: Extremely fast and efficient because Sets use a hash table for storage.
	* Cons: Assumes that the element being deleted exists in the Set.

**Other Alternatives**

For larger arrays or datasets, other data structures like linked lists, trees, or graphs might be more suitable than Arrays. Additionally, libraries like NumJS or Highcharts offer optimized implementations of mathematical and geometric operations, which could potentially outperform native JavaScript methods for specific use cases.

Keep in mind that the performance differences between these approaches can vary depending on the specific use case, hardware, and JavaScript engine being used.

Related benchmarks:

Array indexOf and splice vs Set delete - good (version: 1)

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

Created: 2 years ago by: Registered User

Jump to the latest result

indexOf arr10

delete set10

indexOf arr30

delete set30

indexOf arr100

delete set100

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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