Benchmark: set.has vs. array.includes vs object lookup (larger array)

Script Preparation code:

var a = new Array(10000).fill(null).map((_, i) => i).sort(() => Math.random() - 0.5)
var b = new Set(a)
var c = a.reduce((a, b) => ({ ...a, b: true }), {})

Tests:

includes
return a.includes(1)
lookup
return b.has(1)
object key
return c[1]
array find
return a.find(n => n === 100)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
lookup
object key
array find

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 months 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
includes	3715081.8 Ops/sec
lookup	180131648.0 Ops/sec
object key	176005232.0 Ops/sec
array find	217228.8 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark described tests the performance of different methods for checking whether a value exists in a data structure, specifically focusing on:

1. **Array.includes()**
2. **Set.has()**
3. **Object key lookup**
4. **Array.find()**

### Options Compared:

1. **Array.includes(value)**
   - **Description:** This method checks if an array contains a certain element. It returns `true` if the element is found, otherwise it returns `false`.
   - **Performance:** This method iterates through the elements of the array until it finds the value, which results in a time complexity of \(O(n)\) in the worst case.

2. **Set.has(value)**
   - **Description:** This method checks if a `Set` object contains a certain value. Sets are a collection of unique values and are designed for efficient lookups.
   - **Performance:** The `Set` provides average time complexity of \(O(1)\) for lookups, making it very efficient for determining the presence of an element.

3. **Object key lookup (using an object)**
   - **Description:** This method involves creating an object where the keys are the values we want to check. To check for existence, we access the key on the object.
   - **Performance:** Similar to Sets, this has average time complexity of \(O(1)\) for lookups. However, its efficiency can be influenced by issues like key collision, though in practice, this is often negligible for small lookup tables.

4. **Array.find(callback)**
   - **Description:** This method returns the first element in the array that satisfies the provided testing function or `undefined` if no elements match.
   - **Performance:** It has a time complexity of \(O(n)\) in the worst case, as it may need to inspect all elements of the array.

### Performance Results:

From the benchmark results provided, we can observe the following executions per second for each method:

- Lookup with Set (`b.has(1)`): 180,131,648.0
- Object key lookup (`c[1]`): 176,005,232.0
- Array includes method (`a.includes(1)`): 3,715,081.75
- Array find method (`a.find(n => n === 100)`): 217,228.796875

### Pros and Cons:

- **Array.includes()**
  - **Pros:** Simple syntax and effectively communicates intent.
  - **Cons:** Performance is suboptimal for large arrays due to its linear search approach.

- **Set.has()**
  - **Pros:** High performance with average \(O(1)\) complexity for lookups; ideal for scenarios requiring frequent existence checks.
  - **Cons:** Requires additional memory to store the values; not suitable if the values need to be in order or an array's specific features are required.

- **Object key lookup**
  - **Pros:** Similar performance to Set; can use existing objects; provides quick lookups.
  - **Cons:** Limited to string keys and can have unexpected behavior with certain edge cases in JavaScript.

- **Array.find()**
  - **Pros:** Allows for more complex conditions that are beyond simple existence checks.
  - **Cons:** Less efficient for mere existence checks; also requires traversal of the array.

### Other Alternatives:

While the above techniques are effective, other alternatives include:

- **Using a Map:** Similar to an object but allows any data type as keys.
- **Array.prototype.indexOf():** While this method can also be used to check for existence, it is functionally similar to `Array.includes()` but returns the index.
- **Binary Search (for sorted arrays):** If the array is sorted, binary search can be very efficient, reducing the time complexity to \(O(\log n)\).

Overall, the choice of which method to use should depend on the expected size of the dataset, whether duplicates are allowed, and whether quick lookups are essential for the use case in question. For large datasets with frequent lookups, `Set.has()` or object key lookups are typically the best choices.

Related benchmarks:

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

Comparing performance of: includes vs lookup vs object key vs array find

Created: 2 months ago by: Guest

Jump to the latest result

includes

lookup

object key

array find

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