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

Script Preparation code:

const item_1 = Math.floor(1 / 2);
const array_1 = new Array(1).fill(0).map((_, i) => i);
const set_1 = new Set(array_1);

const item_2 = Math.floor(2 / 2);
const array_2 = new Array(2).fill(0).map((_, i) => i);
const set_2 = new Set(array_2);

const item_4 = Math.floor(4 / 2);
const array_4 = new Array(4).fill(0).map((_, i) => i);
const set_4 = new Set(array_4);

const item_8 = Math.floor(8 / 2);
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 (Android 11; Mobile; rv:136.0) Gecko/136.0 Firefox/136.0

Browser/OS: Firefox Mobile 136 on Android

View result in a separate tab

Test name	Executions per second
array_1	20402522.0 Ops/sec
set_1	535945088.0 Ops/sec
array_2	20027638.0 Ops/sec
set_2	535038176.0 Ops/sec
array_4	19272594.0 Ops/sec
set_4	530497504.0 Ops/sec
array_8	18608556.0 Ops/sec
set_8	533195424.0 Ops/sec

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

LLMs can make mistakes. Check important info.

### Benchmark Overview

The benchmark named "Set.has vs Array.includes for small number of items (fixed)" aims to compare two different data structures in JavaScript, `Set` and `Array`, in the context of checking for the existence of an element. Specifically, it measures the performance of the `has()` method of the `Set` data structure against the `includes()` method of the `Array` data structure.

### What is Tested

1. **Data Structures**: 
   - **Array**: A list-like object that allows storing sequences of values. The `includes()` method checks if a given value is present in the array.
   - **Set**: A collection of unique values. The `has()` method checks if a specific value exists in the set, offering O(1) average time complexity for lookups.

### Options Compared

The benchmark compares the following test cases, using arrays and sets of different sizes (1, 2, 4, and 8):

1. **Array.includes(item)** vs. **Set.has(item)**

Each test evaluates how fast the respective method can find an item in the array or set.

### Performance Results

According to the latest benchmark results, we find the performance in terms of `ExecutionsPerSecond` for each test name:

- **Set Tests**:
  - `set_1`: 99,745,160
  - `set_2`: 95,005,656
  - `set_4`: 97,195,616
  - `set_8`: 94,054,528
  
- **Array Tests**:
  - `array_1`: 91,191,352
  - `array_2`: 87,958,704
  - `array_4`: 84,315,040
  - `array_8`: 75,146,104

From the performance metrics, it appears that `Set.has()` consistently outperforms `Array.includes()` across all tested sizes. Notably, the performance difference becomes more significant as the size of the data structure increases.

### Pros and Cons of Each Approach

- **Set.has()**:
  - **Pros**:
    - Fast lookups (average O(1) time complexity).
    - Ideal for scenarios involving large datasets where frequent membership checks are needed.
  - **Cons**:
    - Requires storage of unique values, which could be a drawback if duplicates are necessary.
    - Slightly larger memory overhead compared to arrays due to its underlying structure.

- **Array.includes()**:
  - **Pros**:
    - Simpler and more intuitive for small arrays or when working with non-unique values.
    - Lower overhead if you frequently need to manage duplicate values.
  - **Cons**:
    - Slower lookups (O(n) average time complexity) especially with larger datasets, as it requires scanning the array to check for existence.

### Other Considerations

- **Memory Overheads**: While the performance is key during lookups, the choice between using a `Set` and an `Array` might also be influenced by the overall memory consumption—arrays can be lighter in scenarios with duplicates, while sets may consume more memory.
  
- **Use Cases**: The best choice between these data structures depends on the context:
  - Use `Set` when dealing with large datasets and the uniqueness of items is an advantage. 
  - Use `Array` when the simplicity of implementation or the need for duplicate storage is a priority.

### Alternatives

- **Object and Map**: In JavaScript, objects (or `Map`) can also be used for fast key-based lookups. However, they are primarily key-value stores rather than being strictly collections like arrays or sets.

- **Custom Search Implementations**: For specific applications, implementing custom search functions or algorithms (like binary search on sorted arrays) could offer more optimized performance but would require more complexity and careful implementation.

This benchmark serves as a useful guide for developers to make informed choices when deciding between using `Set` or `Array` for membership checks in JavaScript, ensuring optimal performance based on the requirements of their applications.

Related benchmarks:

Set.has vs Array.includes for small number of items (fixed) (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):