Benchmark: set.has vs. array.includes vs plain object

Script Preparation code:

var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var b = new Set(a);
var c = Object.fromEntries(a.map(e => [e, true]));

Tests:

Array.includes
return a.includes(3)
Set.has
return b.has(3)
Object access
return c[3]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.includes
Set.has
Object access

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36

Browser/OS: Chrome 132 on Windows

View result in a separate tab

Test name	Executions per second
Array.includes	27648690.0 Ops/sec
Set.has	38309336.0 Ops/sec
Object access	36524808.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark outlined in the provided JSON compares three different methods for checking the presence of an element in a collection: using an array with the `Array.includes()` method, using a `Set` with the `Set.has()` method, and using a plain object for direct property access. The main goal is to evaluate the performance of these approaches in terms of execution speed.

### Options Compared

1. **Array.includes()**
   - **Description**: This method checks if a specific value exists in an array. It returns `true` if the value is found, and `false` otherwise.
   - **Pros**:
     - Easy to read and intuitive for checking presence in arrays.
     - Provides a straightforward approach for developers who are more familiar with arrays.
   - **Cons**:
     - Performance can degrade with larger arrays because it checks every element until it finds a match (linear time complexity O(n)).
  
2. **Set.has()**
   - **Description**: This method checks for the existence of a value in a `Set`, which is a collection of unique values.
   - **Pros**:
     - Very efficient for membership checks, offering average time complexity of O(1) due to its underlying hash table structure.
     - Automatically prevents duplicates when adding elements.
   - **Cons**:
     - Requires additional memory compared to arrays since a `Set` is a separate object.
     - Slightly more complex to implement for fewer items compared to the more conventional array methods.

3. **Object Access**
   - **Description**: This method uses an object where the keys represent the items being checked, and a `true` value signifies the presence of each element.
   - **Pros**:
     - Also offers average time complexity of O(1) for checks, similar to `Set`.
     - Works well for situations where you need to track the presence of many distinct keys.
   - **Cons**:
     - Less semantic clarity compared to the `Set` for checking membership, as it diverges from the typical collection model in JavaScript.
     - More manual setup is required to create the object, such as initializing the object keys.

### Considerations

- **Memory Usage**: `Set` and object access may use more memory than arrays due to their internal structures. This should be considered when working with numerous elements.
- **Use Case Suitability**: Depending on the use case (e.g., frequent lookups vs. more read operations), one method might be more suitable than others.
- **Browser Performance Variability**: Results may vary across different browsers and platforms, emphasizing the importance of testing in the intended environment.

### Benchmark Results Analysis

The results indicate the number of executions per second for each method on a specific test using Chrome on Windows.

- **Set.has** exhibited the highest performance with **38,309,336** executions per second.
- **Object access** followed, with **36,524,808** executions per second.
- **Array.includes** had the lowest performance at **27,648,690** executions per second.

This suggests that using `Set` is the most efficient for element presence checks in terms of execution speed, followed closely by direct object access, with the array method being the least performant.

### Alternatives

Besides the methods tested, alternatives could include:

- **Using other data structures**: For very large datasets or specialized situations, one might consider balanced binary search trees (like Red-Black Trees) or implementing a custom hash table.
- **Tailored Algorithms**: For sorted arrays, binary search could be an option for efficient checks, but it requires that the array be sorted beforehand.

In conclusion, the benchmark provides clear insights into the performance implications of element presence checks in JavaScript collections, helping developers choose the most appropriate method based on their specific needs.

Related benchmarks:

set.has vs. array.includes vs plain object (version: 1)

Comparing performance of: Array.includes vs Set.has vs Object access

Created: 2 months ago by: Guest

Jump to the latest result

Array.includes

Set.has

Object access

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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