Benchmark: set includes vs array includes vs or, for two values

Script Preparation code:

const valueArray = [1, 2];
const valueSet = new Set([1, 2]);
const a = 1;
const b = 2;
const c = 3;

Tests:

Array 1
function array1() { valueArray.includes(1); } for (var i = 0; i < 1e5; ++i) { array1(); }
Array 2
function array2() { valueArray.includes(2); } for (var i = 0; i < 1e5; ++i) { array2(); }
Array 3
function array3() { valueArray.includes(3); } for (var i = 0; i < 1e5; ++i) { array3(); }
if 1
function if1() { if (a === a || a === b) {} } for (var i = 0; i < 1e5; ++i) { if1(); }
if 2
function if2() { if (b === a || b === b) {} } for (var i = 0; i < 1e5; ++i) { if2(); }
if 3
function if3() { if (c === a || c === b) {} } for (var i = 0; i < 1e5; ++i) { if3(); }
Set 1
function set1() { valueSet.has(1); } for (var i = 0; i < 1e5; ++i) { set1(); }
Set 2
function set2() { valueSet.has(2); } for (var i = 0; i < 1e5; ++i) { set2(); }
Set 3
function set3() { valueSet.has(1); } for (var i = 0; i < 1e5; ++i) { set3(); }
Inline Set 1
function inlineSet1() { new Set([1, 2]).has(1); } for (var i = 0; i < 1e5; ++i) { inlineSet1(); }
Inline set 2
function inlineSet2() { new Set([1, 2]).has(2); } for (var i = 0; i < 1e5; ++i) { inlineSet2(); }
Inline set 3
function inlineSet3() { new Set([1, 2]).has(3); } for (var i = 0; i < 1e5; ++i) { inlineSet3(); }
Inline const set 1
function inlineConstSet1() { const inlineValueConstSet1 = new Set([1, 2]); inlineValueConstSet1.has(1); } for (var i = 0; i < 1e5; ++i) { inlineConstSet1(); }
Inline const set 2
function inlineConstSet2() { const inlineValueConstSet2 = new Set([1, 2]); inlineValueConstSet2.has(2); } for (var i = 0; i < 1e5; ++i) { inlineConstSet2(); }
Inline const set 3
function inlineConstSet3() { const inlineValueConstSet3 = new Set([1, 2]); inlineValueConstSet3.has(3); } for (var i = 0; i < 1e5; ++i) { inlineConstSet3(); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array 1
Array 2
Array 3
if 1
if 2
if 3
Set 1
Set 2
Set 3
Inline Set 1
Inline set 2
Inline set 3
Inline const set 1
Inline const set 2
Inline const set 3

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

This benchmark focuses on comparing different methods of checking for the inclusion of values in JavaScript arrays and sets. The tests set out to evaluate the performance of various approaches, particularly when checking for specific values using both arrays and sets.

### Breakdown of Options Compared

1. **Array Includes Method**:
   - **Tests**: `Array 1` checks for the presence of `1`, `Array 2` checks for `2`, and `Array 3` checks for `3`.
   - **Implementation**: The `includes()` method, which returns `true` if a specified value is found in the array, and `false` otherwise.
   - **Pros**:
     - Simple to understand and use.
     - Supports searching for any value within the array.
   - **Cons**:
     - O(n) time complexity since it may need to traverse the entire array to find the value, making it slower with larger arrays.
  
2. **Set Has Method**:
   - **Tests**: `Set 1` checks for `1`, `Set 2` checks for `2`, and `Set 3` checks for `1` again.
   - **Implementation**: The `has()` method of the `Set` object, which checks if a value exists in the set.
   - **Pros**:
     - O(1) average time complexity, which significantly enhances performance when checking for existence.
     - Sets do not allow duplicate values, naturally handling unique collections.
   - **Cons**:
     - Requires more memory to hold additional data structures.
     - Introduces overhead for managing sets compared to arrays for small or simple collections.
  
3. **Inline Set**:
   - **Tests**: `Inline Set 1`, `Inline Set 2`, and `Inline Set 3` create a new `Set` for each check.
   - **Implementation**: Creates a new `Set` object each time the function is called.
   - **Pros**:
     - Can be useful for one-off checks without needing a persistent set.
   - **Cons**:
     - Performance suffers due to the repeated creation of new sets, making it significantly slower than using an existing `Set`.

4. **Inline Const Set**:
   - **Tests**: `Inline const set 1`, `Inline const set 2`, and `Inline const set 3` also create a new `Set` within a constant variable.
   - **Implementation**: Like inline sets, but using a constant to hold the set.
   - **Pros**:
     - Similar benefits to inline sets but ensures the set reference stays consistent within that function scope.
   - **Cons**:
     - Still incurs performance costs from repeated instantiation.

5. **If Conditions**:
   - **Tests**: `If 1`, `If 2`, `If 3` each check values through simple boolean comparisons.
   - **Implementation**: Uses straightforward conditional statements to check for specific values.
   - **Pros**:
     - Fast O(1) time complexity as it evaluates conditions directly.
     - Less overhead compared to managing arrays or sets.
   - **Cons**:
     - Not dynamic; it checks for hardcoded values, making it less flexible for varying input scenarios.

### Other Considerations

- **Performance Results**: The benchmark results indicate the fastest checks involve conditionals (the `if` statements), while array checks were shown to be considerably slower. Set checks performed better than array checks but not as well as conditionals, exemplifying a classic trade-off between data structure benefits and execution speed for specific operations.
  
- **Scalability**: For larger data sets or applications needing frequent existence checks, using sets is often a better option due to their efficiency with O(1) time complexity, but design considerations for memory usage and initialization should also be evaluated.

### Alternatives

Other alternatives and methods could include:

1. **Using Loops with Custom Logic**: Instead of `includes()` for arrays, implementing binary search on sorted arrays for faster lookups.
2. **Maps**: Utilizing `Map` for key-value pairs might be beneficial if checking combines both existence and retrieval operations.
3. **Typed Arrays**: For numeric data specifically, using typed arrays (e.g., `Uint8Array`) could offer optimizations.
4. **Third-party libraries**: Libraries like Lodash or underscore offer utility functions that may provide optimized or more comprehensive checks over collections.

In summary, the benchmark clearly distinguishes the efficacy of conditionals over data structures for simple value checks while demonstrating the unique strengths of sets for larger, dynamic datasets. Understanding how to best leverage these options is crucial for efficient JavaScript development.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:132.0) Gecko/20100101 Firefox/132.0

Browser/OS: Firefox 132 on Windows

View result in a separate tab

Test name	Executions per second
Array 1	295.7 Ops/sec
Array 2	305.6 Ops/sec
Array 3	282.1 Ops/sec
if 1	1280.4 Ops/sec
if 2	1309.9 Ops/sec
if 3	1083.5 Ops/sec
Set 1	849.8 Ops/sec
Set 2	1115.1 Ops/sec
Set 3	1039.7 Ops/sec
Inline Set 1	13.8 Ops/sec
Inline set 2	14.2 Ops/sec
Inline set 3	13.8 Ops/sec
Inline const set 1	14.1 Ops/sec
Inline const set 2	14.1 Ops/sec
Inline const set 3	9.7 Ops/sec

Related benchmarks:

set includes vs array includes vs or, for two values (version: 3)

Comparing performance of: Array 1 vs Array 2 vs Array 3 vs if 1 vs if 2 vs if 3 vs Set 1 vs Set 2 vs Set 3 vs Inline Set 1 vs Inline set 2 vs Inline set 3 vs Inline const set 1 vs Inline const set 2 vs Inline const set 3

Created: 3 days ago by: Registered User

Jump to the latest result

Array 1

Array 2

Array 3

if 1

if 2

if 3

Set 1

Set 2

Set 3

Inline Set 1

Inline set 2

Inline set 3

Inline const set 1

Inline const set 2

Inline const set 3

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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