Benchmark: 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).map((_, i) => i);
const set_1 = new Set(array_1);

const item_2 = Math.floor(Math.random() * 2);
const array_2 = new Array(2).map((_, i) => i);
const set_2 = new Set(array_2);

const item_4 = Math.floor(Math.random() * 4);
const array_4 = new Array(4).map((_, i) => i);
const set_4 = new Set(array_4);

const item_8 = Math.floor(Math.random() * 8);
const array_8 = new Array(8).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: one month ago)

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

Browser/OS: Chrome 145 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
array_1	171550800.0 Ops/sec
set_1	258738272.0 Ops/sec
array_2	153307184.0 Ops/sec
set_2	246484464.0 Ops/sec
array_4	134234400.0 Ops/sec
set_4	249682480.0 Ops/sec
array_8	101009456.0 Ops/sec
set_8	241585312.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON compares the performance of two different methods for checking the existence of items in collections: using an `Array.includes()` method versus a `Set.has()` method. The benchmark focuses on a small number of items to assess the performance differences between these two approaches. Here's a detailed breakdown:

### Options Being Compared

1. **Array.includes(item)**:
   - This method checks if a specific item exists within an array.
   - It iterates through the array elements until it finds the item, resulting in a time complexity of O(n) in the worst case, where n is the number of elements in the array.
   - Each test case uses arrays of sizes 1, 2, 4, and 8 items.

2. **Set.has(item)**:
   - This method checks if a specific item exists within a Set, which is a data structure that allows for the storage of unique values.
   - It typically has a time complexity of O(1) for lookups due to the underlying hash table implementation of Sets.
   - Similar to the previous method, each test case evaluates Sets of sizes 1, 2, 4, and 8 items.

### Pros and Cons of Each Approach

#### **Array.includes()**
- **Pros**:
  - Simple and straightforward to use; arrays are a common data structure in JavaScript.
  - Suitable for small datasets where performance is not critical.
  
- **Cons**:
  - Performance degrades as the size of the array increases, especially for larger datasets, as each lookup may require scanning through the entire array.
  - Cannot guarantee the uniqueness of items by default (unless you manually validate it).

#### **Set.has()**
- **Pros**:
  - Provides O(1) average time complexity for lookups, making it much faster than alternatives for large datasets.
  - Ensures the uniqueness of values automatically, which can prevent duplicates in collections.

- **Cons**:
  - Slightly more complex than using arrays, as Sets are a less commonly used structure in certain scenarios.
  - Introduces some overhead if items need to be maintained in insertion order, as Sets do not inherently preserve order like Arrays do (though they do preserve insertion order in JavaScript).

### Other Considerations
- The benchmark specifically tests with small numbers of items (1, 2, 4, and 8) to see the comparative performance. The expected advantage of using Sets is likely to be more pronounced with significantly larger datasets.
- The results show that, even at these small sizes, `Set.has()` outperformed `Array.includes()`, particularly notable when more items were involved.

### Alternatives
In addition to using Arrays and Sets, there are alternative methods to consider for similar operations:
1. **Object Keys**: Using an object as a dictionary for key-value pairs can provide O(1) lookups. However, this is less intuitive than using Sets.
2. **Maps**: Similar to Sets but allows key-value pairs while still providing O(1) lookup time.
3. **Linked Lists or Trees**: These structures can facilitate specific use cases but typically don't provide direct lookup benefits.

### Conclusion
The benchmark allows engineers to understand the trade-offs between two fundamental data structures in JavaScript. As JavaScript applications scale and performance becomes a critical factor, choosing the right data structure based on the expected operations can substantially improve efficiency. Sets generally offer a more performant solution for membership tests, while arrays remain valuable for ordered collections and small datasets.

Related benchmarks:

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: one year 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>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):