Benchmark: Set.has vs Array.includes for small number of items Bv2

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

const array_1 = new Array(1).map((_, i) => self.crypto.randomUUID()
);
const set_1 = new Set(array_1);
const item_1 = array_1[0];

const array_2 = new Array(1, 2).map((_, i) => self.crypto.randomUUID()
);
const set_2 = new Set(array_2);
const item_2 = array_2[1];

const array_4 = new Array(1, 2, 3, 4).map((_, i) => self.crypto.randomUUID()
);
const set_4 = new Set(array_4);
const item_4 = array_2[3];

const array_8 = new Array(1, 2, 3, 4, 5, 6, 7, 8).map((_, i) => self.crypto.randomUUID()
);
const set_8 = new Set(array_8);
const item_8 = array_2[7];

Tests:

array_1
array_1.includes(item_1)
set_1
set_1.has(item_1)
array_8
array_8.includes(item_8)
set_8
set_8.has(item_8)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array_1
set_1
array_8
set_8

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

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

Browser/OS: Chrome 132 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
array_1	111677096.0 Ops/sec
set_1	103426296.0 Ops/sec
array_8	94897240.0 Ops/sec
set_8	90601432.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

The benchmark provided tests the performance of two distinct data structures in JavaScript: the `Array` and the `Set`. The specific focus is on the speed of checking for the existence of an element in these structures using two different methods: `Array.includes()` and `Set.has()`. This comparison is critical for understanding the efficiency of these data structures when handling small sets of items.

### Benchmark Details

#### Data Structures and Methods:

1. **Array**:
   - **Method Tested**: `.includes(item)`
   - **Description**: The `Array.includes()` method determines whether an array contains a certain value among its entries, returning `true` or `false` as appropriate. It performs a linear search through the array, meaning the time taken to check for an item grows linearly with the number of items in the array (O(n) complexity).

2. **Set**:
   - **Method Tested**: `.has(item)`
   - **Description**: The `Set.has()` method checks for the existence of a specified value in a `Set`, returning `true` or `false`. Sets utilize a hash table internally, allowing for average-case time complexity of O(1) for lookups, which means that regardless of the number of items in the set, checking for the presence of an item is effectively constant time.

#### Benchmark Preparation Code

The preparation code generates a series of unique identifiers using `self.crypto.randomUUID()` to create random values to be tested against both arrays and sets. It creates:

- `array_1` with 1 item and corresponding `set_1`
- `array_2` with 2 items and corresponding `set_2`
- `array_4` with 4 items and corresponding `set_4`
- `array_8` with 8 items and corresponding `set_8`

### Test Cases

There are four tests cases executed in this benchmark:

1. **`array_1.includes(item_1)`**: Tests performance on a small array of 1 item.
2. **`set_1.has(item_1)`**: Tests performance on a small set of 1 item.
3. **`array_8.includes(item_8)`**: Tests performance on a larger array of 8 items.
4. **`set_8.has(item_8)`**: Tests performance on a larger set of 8 items.

### Results Summary

- **Performance (Executions Per Second)**:
  - **array_1**: 111,677,096
  - **set_1**: 103,426,296
  - **array_8**: 94,897,240
  - **set_8**: 90,601,432

The benchmark results reveal that both methods performed quite well, with the `Array.includes()` method slightly outperforming the `Set.has()` method in both cases (for the small and larger datasets). This may seem counterintuitive given the theoretical complexities; however, the performance results may be influenced by several factors, such as optimizations in the JavaScript engine or the relatively small sizes of the data structures.

### Pros and Cons of Each Approach

- **Array.includes()**:
  - **Pros**:
    - Simple and easy to use.
    - Returns correct results regardless of item types (including NaN).
  - **Cons**:
    - Performance degrades linearly with the number of elements in the array, making it less efficient for larger datasets.

- **Set.has()**:
  - **Pros**:
    - Extremely efficient for larger datasets due to average constant time complexity (O(1)).
    - Avoids duplicates naturally, preserving unique values.
  - **Cons**:
    - Slightly more overhead in terms of memory compared to arrays, as it requires maintaining a hash table.

### Alternatives
For checking the existence of an item in JavaScript, other data structure alternatives could include:

1. **Object**: Using key-value pairs in a plain JavaScript object can be a lightweight alternative for existence checks, utilizing object properties for fast lookup but lacking the built-in methods of the `Set`.

2. **Map**: Similar to `Set`, but stores key-value pairs. It also offers O(1) lookup complexity. Maps are useful when you need to associate values with keys.

3. **Typed Arrays**: If the use case involves numerical data, JavaScript's typed arrays can deliver performance gains during lookups.

Ultimately, the choice between these data structures should be driven by specific application needs, including the size of the data, performance requirements, and memory constraints.

Related benchmarks:

Set.has vs Array.includes for small number of items Bv2 (version: 1)

Comparing performance of: array_1 vs set_1 vs array_8 vs set_8

Created: 3 months ago by: Guest

Jump to the latest result

array_1

set_1

array_8

set_8

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):