Benchmark: set vs array mod

Script Preparation code:

const b = []
for (let i = 0; i < 3000; i++) b.push(i)
const c = new Set(b);

Tests:

array.push
const a = [] for (let i = 0; i < 3000; i++) a.push(i)
set.add
const s = new Set() for (let i = 0; i < 3000; i++) s.add(i)
array.shift
for (let i = 0; i < 3000; i++) b.shift()
set.delete
for (let i = 0; i < 3000; i++) c.delete(i)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array.push
set.add
array.shift
set.delete

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 21 days ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:137.0) Gecko/20100101 Firefox/137.0

Browser/OS: Firefox 137 on Linux

View result in a separate tab

Test name	Executions per second
array.push	288902.6 Ops/sec
set.add	15536.0 Ops/sec
array.shift	146822.1 Ops/sec
set.delete	72129.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 21 days ago):

LLMs can make mistakes. Check important info.

### Benchmark Overview: "set vs array mod"

This benchmark compares the performance of operations on JavaScript arrays and Sets. The focus is on specific actions: adding and removing elements, which are common operations in many applications. The operations being compared include:

1. **Adding elements** to an array using `push` vs. adding elements to a set using `add`.
2. **Removing elements** from an array using `shift` (removes the first element) vs. removing elements from a set using `delete`.

### Benchmark Preparation Code

Before executing the individual test cases, the benchmark initializes a baseline array of 3000 elements (from 0 to 2999) and uses this to create a Set, which will then be used in the tests involving Set operations:

```javascript
const b = []
for (let i = 0; i < 3000; i++) b.push(i)
const c = new Set(b);
```

### Individual Test Cases

1. **array.push**: 
   - **Code**: `const a = [] for (let i = 0; i < 3000; i++) a.push(i)`
   - **Description**: This tests the `push` method, which adds an element to the end of the array. It's expected to be very fast in JavaScript since it is an O(1) operation.

2. **set.add**: 
   - **Code**: `const s = new Set() for (let i = 0; i < 3000; i++) s.add(i)`
   - **Description**: This tests the `add` method of Set, which inserts a new element. However, when inserting elements, if the element already exists in the Set, it won't be added again. Typically, the average time complexity for adding is also O(1) but can degrade under certain conditions.

3. **array.shift**: 
   - **Code**: `for (let i = 0; i < 3000; i++) b.shift()`
   - **Description**: This tests the `shift` method, which removes the first element from the array. This operation is O(n) because all remaining elements need to be re-indexed.

4. **set.delete**: 
   - **Code**: `for (let i = 0; i < 3000; i++) c.delete(i)`
   - **Description**: This tests the `delete` method of Set, which removes an element. The expected average complexity is O(1), similar to `add`.

### Performance Results Summary

The results from the benchmark show the number of executions per second for each test case, which provides insight into the relative performance:

- **array.push**: Executes at 288,902.56 times per second, indicating it is very efficient.
- **array.shift**: Executes at 146,822.11 times, showing it is significantly slower than push due to its linear time complexity.
- **set.delete**: Executes at 72,128.97 times per second, which indicates efficient removal but slower than simple array operations.
- **set.add**: This shows only 15,535.99 executions, which is relatively low, and this is likely because each `set.add` operation must check for uniqueness, which could cause the slower performance observed.

### Pros and Cons

#### Arrays:
- **Pros**:
  - Fast append with `push`.
  - Easy to use with standard methods for manipulating elements.
- **Cons**:
  - Removing the first element (`shift`) is costly (O(n)) as it re-indexes the array.

#### Sets:
- **Pros**:
  - Hash-based implementation allows average constant time complexity for `add` and `delete`.
  - Guarantees uniqueness, which is useful in many scenarios.
- **Cons**:
  - Slower on average for adding elements than arrays, especially if many elements already exist.

### Other Alternatives

Besides arrays and Sets, there are other data structures available in JavaScript:

1. **Maps**: Similar to Sets, but they store key-value pairs and preserve the insertion order.
2. **Custom Data Structures**: Depending on the needs, developers might implement linked lists, binary trees, or other more complex structures if they need performance characteristics that arrays or sets do not provide.

In conclusion, the benchmark provides insight into the performance trade-offs when using arrays vs. sets in JavaScript for common operations, highlighting the fast `push` operation of arrays against the potential benefits of Sets when it comes to ensuring unique elements.

Related benchmarks:

set vs array mod (version: 1)

Comparing performance of: array.push vs set.add vs array.shift vs set.delete

Created: 21 days ago by: Guest

Jump to the latest result

array.push

set.add

array.shift

set.delete

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 21 days ago):