Benchmark: Array.includes() vs Set.has() for small Arrays invoked multiple times

Script Preparation code:

function getArray(length) {
  const result = [];
  for (let i = 0; i < length; i++) {
    result.push(i + 'abc'); // In case the browser does some sort of optimization for arrays with only integers ¯\_(ツ)_/¯
  }
  return result;
}

function getRandomTargetElement(arrayLength) {
  const index = Math.floor(Math.random() * arrayLength);
  return index + 'abc';
}


array_small = getArray(20);

set_small = new Set(array_small);

Tests:

Array.includes, 20 elements
array_small.includes(getRandomTargetElement(20));
Set.has, 20 elements
set_small.has(getRandomTargetElement(20))
Array to Set + Set.has x 1000, 20 elements
const set = new Set(array_small); for (let i = 0; i < 1000; i++) { const target = getRandomTargetElement(20); set.has(target) }
Array.includes x 1000, 20 elements
for (let i = 0; i < 1000; i++) { const target = getRandomTargetElement(20); array_small.includes(target) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.includes, 20 elements
Set.has, 20 elements
Array to Set + Set.has x 1000, 20 elements
Array.includes x 1000, 20 elements

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/133.0.0.0 Safari/537.36

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array.includes, 20 elements	18464856.0 Ops/sec
Set.has, 20 elements	35651828.0 Ops/sec
Array to Set + Set.has x 1000, 20 elements	41121.6 Ops/sec
Array.includes x 1000, 20 elements	20633.7 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark described in the provided JSON is focused on comparing the performance of the JavaScript methods `Array.includes()` and `Set.has()` when used with small arrays containing 20 elements.

### Options Compared
1. **Array.includes()**
   - **Test Case**: `array_small.includes(getRandomTargetElement(20));`
   - **Description**: This test checks whether a randomly selected element from the array exists in an array.
   - **Nature**: The method returns a boolean indicating the presence of the element. It performs a linear search through the array, thus having a time complexity of O(n).

2. **Set.has()**
   - **Test Case**: `set_small.has(getRandomTargetElement(20));`
   - **Description**: Similar to `Array.includes()`, but here the check is on a Set, which is a collection of unique values.
   - **Nature**: This method operates in average O(1) time complexity since Sets are implemented as hash tables, allowing for faster lookups.

3. **Array to Set Conversion with Set.has()**
   - **Test Case**: 
     ```javascript
     const set = new Set(array_small);
     for (let i = 0; i < 1000; i++) {
       const target = getRandomTargetElement(20);
       set.has(target)
     }
     ```
   - **Description**: This test creates a Set from the original array and checks for membership of random elements 1000 times.
   - **Purpose**: This evaluates the overhead of converting an array to a Set for numerous membership tests.

4. **Array.includes() in a Loop**
   - **Test Case**:
     ```javascript
     for (let i = 0; i < 1000; i++) {
       const target = getRandomTargetElement(20);
       array_small.includes(target);
     }
     ```
   - **Description**: This measures the performance of the `Array.includes()` method when used repetitively to check 1000 random elements.
   - **Nature**: Here, we'll see cumulative deficiencies of linear search as it is repeated.

### Pros and Cons
**Array.includes()**
- **Pros**: 
  - Simple to use and understand.
  - Works directly on array data structures.
- **Cons**: 
  - Performance decreases linearly with the size of the array due to its O(n) complexity.

**Set.has()**
- **Pros**: 
  - Much faster lookups on average due to O(1) complexity.
- **Cons**:
  - Requires additional memory to hold the Set, which might not be efficient for very small arrays or sets.

**Array to Set + Set.has()**
- **Pros**: 
  - Combines the fast lookup of Sets with the flexibility of Arrays.
- **Cons**: 
  - Initialization overhead to convert the array into a Set, which may take time if done redundantly.

**Array.includes x 1000**
- **Pros**: 
  - Direct approach to measuring the performance impact of repeated checks.
- **Cons**: 
  - Exposes the linear time complexity's inefficiency when scaled.

### Other Considerations
- **Memory Consumption**: Using Sets requires additional memory compared to using arrays directly.
- **Use Case Appropriateness**: Choosing between `Array.includes()` and `Set.has()` depends on the use case—if you anticipate frequent membership checks, converting to a Set can provide significant performance benefits despite the initial overhead.
  
### Alternatives
1. **Using Objects**: For small datasets, using an object as a map (or dictionary) for membership checks can be another alternative to Sets.
   ```javascript
   let obj = {};
   array_small.forEach(item => obj[item] = true);
   obj[target]; // returns true or false based on membership.
   ```
2. **Filter or Find Methods**: If searching for specific conditions rather than simple membership, `Array.filter()` or `Array.find()` can be alternatives, though these methods also have linear time complexity.

In conclusion, the benchmark evaluates the trade-offs between using `Array.includes` and `Set.has`, emphasizing the importance of selecting the right data structure based on the performance requirements and expected usage patterns.

Related benchmarks:

Array.includes() vs Set.has() for small Arrays invoked multiple times (version: 1)

Comparing performance of: Array.includes, 20 elements vs Set.has, 20 elements vs Array to Set + Set.has x 1000, 20 elements vs Array.includes x 1000, 20 elements

Created: one month ago by: Guest

Jump to the latest result

Array.includes, 20 elements

Set.has, 20 elements

Array to Set + Set.has x 1000, 20 elements

Array.includes x 1000, 20 elements

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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