Benchmark: Array.includes vs Set.has vas Map.has vs object[k] !== undefined (length 1 million)

Script Preparation code:

const array = Array.from({ length: 1_000_000 }, (v, k) => k);
const entries = array.map((n) => [n,n]);

var arr = [...array];
var set = new Set(array);
var map = new Map(entries);
var obj = Object.fromEntries(entries);
var key = 770908;

Tests:

arr.includes(key)
return arr.includes(key);
set.has(key)
return set.has(key);
map.has(key)
return map.has(key);
obj[key] !== undefined
return obj[key] !== undefined

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
arr.includes(key)
set.has(key)
map.has(key)
obj[key] !== undefined

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Measuring performance in JavaScript is crucial for optimizing code and identifying bottlenecks. The provided benchmarking scenario tests four different approaches to check if an element exists within an array, set, or object.

**Approaches being compared:**

1. `arr.includes(key)`: This method checks if the specified value (`key`) is present in the array.
2. `set.has(key)`: This method returns a boolean indicating whether the specified value (`key`) is present in the Set.
3. `map.has(key)`: Similar to `set.has()`, this method checks for key existence in the Map.
4. `obj[key] !== undefined`: This approach uses object property access to check if the key exists.

**Pros and Cons of each approach:**

1. **`arr.includes(key)`**:
	* Pros: Easy to implement, widely supported, and efficient for large arrays (average time complexity is O(n)).
	* Cons: May be slow for very large arrays due to iteration.
2. **`set.has(key)```:
	* Pros: Fast lookup times (O(1)) on average, and sets are optimized for performance.
	* Cons: Requires a Set data structure, which may not be available in all browsers or environments.
3. **`map.has(key)`**:
	* Pros: Similar to `set.has()`, with fast lookup times (O(1)).
	* Cons: Requires a Map data structure, and the implementation is slightly more complex than for Sets.
4. **`obj[key] !== undefined`**:
	* Pros: Lightweight and easy to implement, as it only requires object property access.
	* Cons: May not be as efficient as other approaches (O(n) average time complexity), especially for large objects.

**Library usage:**

1. `set.has(key)` uses the built-in `Set` data structure in JavaScript, which is optimized for performance and widely supported.
2. `map.has(key)` utilizes the built-in `Map` data structure in JavaScript, similar to `Set`.
3. The other two approaches do not rely on any specific library or external dependency.

**Special JS feature:**

None of the provided approaches require special JavaScript features or syntax beyond standard ECMAScript. However, if using older browsers that don't support modern JavaScript features like Set or Map, these approaches may need to be adapted or replaced with alternative methods.

**Alternative approaches:**

For large arrays:

* Using `filter()` method instead of `includes()`: `arr.filter((value) => value === key)`.
* Utilizing a data structure like a Trie or a Bloom filter for faster lookup times (not as straightforward to implement).

For sets and maps, there are no significant alternatives beyond using the built-in data structures.

For objects:

* Using `in` operator instead of property access: `if (key in obj)`.
* Creating an object with the key-value pair directly: `{ [key]: true }`.

Keep in mind that these alternative approaches might have different trade-offs in terms of performance, complexity, and compatibility.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36

Browser/OS: Chrome 117 on Linux

View result in a separate tab

Test name	Executions per second
arr.includes(key)	477.6 Ops/sec
set.has(key)	1097775.1 Ops/sec
map.has(key)	1079711.9 Ops/sec
obj[key] !== undefined	559875.8 Ops/sec

Related benchmarks:

Array.includes vs Set.has vas Map.has vs object[k] !== undefined (length 1 million) (version: 0)

Comparing performance of: arr.includes(key) vs set.has(key) vs map.has(key) vs obj[key] !== undefined

Created: one year ago by: Guest

Jump to the latest result

arr.includes(key)

set.has(key)

map.has(key)

obj[key] !== undefined

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):