Benchmark: set.has vs. array.includes (strings)

Script Preparation code:

var a = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10'];
var b = new Set(a)

Tests:

includes 1
return a.includes('1')
includes 10
return a.includes('10')
lookup 1
return b.has('1')
lookup 10
return b.has('10')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes 1
includes 10
lookup 1
lookup 10

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 15 days ago)

User agent: Mozilla/5.0 (Android 15; Mobile; rv:137.0) Gecko/137.0 Firefox/137.0

Browser/OS: Firefox Mobile 137 on Android

View result in a separate tab

Test name	Executions per second
includes 1	36834800.0 Ops/sec
includes 10	20904650.0 Ops/sec
lookup 1	1369677824.0 Ops/sec
lookup 10	1370977664.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON focuses on comparing two different methods for checking the existence of elements—specifically strings—within collections in JavaScript. It employs an array and a Set to perform these lookups:

1. **Array's `includes` Method**: This method is used on an array to determine if it contains a certain value.
2. **Set's `has` Method**: This method is used on a Set, which is a collection of unique values, to check if a specific value exists.

### Options Compared

The benchmark examines the performance of the following test cases:

1. **Using Array**:
   - **`return a.includes('1')`**: Tests whether the array `a` contains the string `'1'`.
   - **`return a.includes('10')`**: Tests whether the array `a` contains the string `'10'`.

2. **Using Set**:
   - **`return b.has('1')`**: Tests whether the Set `b` contains the string `'1'`.
   - **`return b.has('10')`**: Tests whether the Set `b` contains the string `'10'`.

### Pros and Cons of Each Approach

#### Array's `includes` Method

**Pros**:
- Simplicity: Easy to read and understand the code.
- Best for smaller datasets: If the array is small, performance may not be significantly different from a Set.

**Cons**:
- Performance: The time complexity is O(n), as it potentially requires iterating through the entire array to find the target value. This can lead to slower lookups as the size of the array increases.

#### Set's `has` Method

**Pros**:
- Performance: The time complexity is O(1) on average, enabling faster lookups regardless of the size of the Set. Sets are optimized for fast membership checks.
- Unique Values: Automatically handles duplicate entries, ensuring that only unique keys are maintained.

**Cons**:
- Overhead: There is a slight overhead in creating a Set compared to a simple array, especially for smaller collections or one-time checks.

### Benchmarked Results

The benchmark results indicate the number of executions per second for each method:

- `lookup 1` using Set's `has` method achieved approximately **70,768,464** operations per second.
- `lookup 10` using Set's `has` method yielded around **66,632,388** operations.
- `includes 1` using array's `includes` method performed at about **51,986,676** per second.
- `includes 10` using array's `includes` method resulted in approximately **29,203,874** operations.

From these results, it's clear that the Set's `has` method is significantly faster than the array's `includes` method, particularly for the benchmark's second lookup. This indicates that for operations where performance and speed are critical, especially with larger datasets, utilizing a Set is more advantageous.

### Other Considerations

- If the data structure is frequently manipulated (e.g., adding and removing elements), the choice between an array and a Set should consider the performance of those operations. Sets generally provide better performance for membership checks, while arrays might be easier for certain types of data handling.
- It's also important to consider the context of the application and the size of the dataset. For small arrays, the performance difference might be negligible, while for larger collections, the difference becomes pronounced.
- Alternative approaches might include using objects for key-value storage (which also offers O(1) lookups for keyed access) or other data structures like Maps, which allow for the same fast lookups with additional benefits like maintaining order.

In summary, this benchmark provides valuable insights into the performance characteristics of different data structures in JavaScript, enabling engineers to make informed decisions based on their specific use cases and performance requirements.

Related benchmarks:

set.has vs. array.includes (strings) (version: 1)

Comparing performance of: includes 1 vs includes 10 vs lookup 1 vs lookup 10

Created: 3 months ago by: Guest

Jump to the latest result

includes 1

includes 10

lookup 1

lookup 10

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