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

Script Preparation code:

const item_1 = Math.floor(Math.random() * 1);
const array_1 = new Array(1).fill(0).map((_, i) => i);
const set_1 = new Set(array_1);

const item_2 = Math.floor(Math.random() * 2);
const array_2 = new Array(2).fill(0).map((_, i) => i);
const set_2 = new Set(array_2);

const item_4 = Math.floor(Math.random() * 4);
const array_4 = new Array(4).fill(0).map((_, i) => i);
const set_4 = new Set(array_4);

const item_8 = Math.floor(Math.random() * 8);
const array_8 = new Array(8).fill(0).map((_, i) => i);
const set_8 = new Set(array_8);

Tests:

array_1
array_1.includes(item_1)
set_1
set_1.has(item_1)
array_2
array_2.includes(item_2)
set_2
set_2.has(item_2)
array_4
array_4.includes(item_4)
set_4
set_4.has(item_4)
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_2
set_2
array_4
set_4
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 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 18 on iOS 18.2.1

View result in a separate tab

Test name	Executions per second
array_1	265603824.0 Ops/sec
set_1	478463520.0 Ops/sec
array_2	210363296.0 Ops/sec
set_2	443106080.0 Ops/sec
array_4	151137344.0 Ops/sec
set_4	508071040.0 Ops/sec
array_8	110071272.0 Ops/sec
set_8	345779680.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark being tested on **MeasureThat.net** compares the performance of two different data structures, **Set** and **Array**, specifically contrasting the `Set.has()` method with `Array.includes()` for small collections of items. The aim is to investigate how fast it is to check for the existence of elements in these data structures when operating on a small number of items.

### Benchmark Details

**Data Structures Tested:**

1. **Array.includes**:
   - This method checks if a specified value exists in the array.
   - It iterates through the array to find the matching value, which means it has a linear time complexity of O(n) in the worst case.

2. **Set.has**:
   - This method checks if a specific value exists in the set.
   - It uses a hash table for storage and has an average time complexity of O(1) for lookups.

### Options Compared:

The benchmark has been structured to evaluate eight cases that use both `Array.includes()` and `Set.has()` methods with different array and set sizes: 1, 2, 4, and 8 elements. Each test consists of:

- **Test Cases**:
  - `array_1.includes(item_1)`
  - `set_1.has(item_1)`
  - `array_2.includes(item_2)`
  - `set_2.has(item_2)`
  - `array_4.includes(item_4)`
  - `set_4.has(item_4)`
  - `array_8.includes(item_8)`
  - `set_8.has(item_8)`

### Results Analysis:

The benchmark results show how many operations per second each method could perform under similar conditions. In the output, the fastest execution recorded was for `set_4`, with 508 million executions per second, while the slowest was `array_8`, at about 110 million executions per second. This indicates a clear performance advantage for the `Set.has()` method over the `Array.includes()` method.

### Pros and Cons:

**Arrays**:
- **Pros**: 
  - Simple to understand and use, widely available features.
  - Easy to use built-in methods for manipulation (such as map, filter, etc.).
- **Cons**: 
  - Slower for membership checks as the array size increases (linear search).

**Sets**:
- **Pros**: 
  - Fast and efficient membership checks (constant average time complexity).
  - Automatically handles uniqueness (duplicate values are not allowed).
- **Cons**: 
  - More memory overhead due to hashing and storing additional data.
  - Complexity may arise in understanding hash collisions and how they are resolved.

### Other Considerations:

- **Best Use Cases**: 
  - Use **arrays** when you need to maintain the order of elements, require frequent enumerations, or need to use array methods extensively.
  - Use **sets** when membership checks are critical and you can take advantage of their efficiency, particularly for large datasets where lookup speed is paramount.

### Alternatives:

Other alternatives for data structures that can also be employed for similar operations include:

1. **Maps**: When key-value pairs with unique keys are needed. They also provide average O(1) performance for lookups.
2. **Sorted Arrays**: If the dataset is small and ordered retrieval is needed, but searches become inefficient without binary search.
3. **Object Literals**: For simple key-value pair storage, but limited to string keys and can involve more overhead for searching compared to Sets.

### Conclusion:

This benchmark showcases the notable performance differences between using a `Set` and an `Array` for membership checks, with `Set.has()` outperforming `Array.includes()` significantly in execution speed across different sizes. Software engineers should favor the `Set` for performance-critical scenarios while remaining aware of the context in which each structure operates best.

Related benchmarks:

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

Comparing performance of: array_1 vs set_1 vs array_2 vs set_2 vs array_4 vs set_4 vs array_8 vs set_8

Created: 3 months ago by: Guest

Jump to the latest result

array_1

set_1

array_2

set_2

array_4

set_4

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