Benchmark: set.has vs. array.includes vs. map.has

Script Preparation code:

var arr = [...Array.from(Array(100000).keys())];
var set = new Set(arr)
var map = new Map(arr.map(k => [k, undefined]))

Tests:

Array.includes
return arr.includes(99999)
Set.has
return set.has(99999)
Map.has
return map.has(99999)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.includes
Set.has
Map.has

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Yandex Browser 24 on Windows

View result in a separate tab

Test name	Executions per second
Array.includes	173368.4 Ops/sec
Set.has	26413580.0 Ops/sec
Map.has	26716736.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON.

The benchmark is designed to compare the performance of three different approaches: using an array with `includes()`, using a Set with `has()`, and using a Map with `has()`.

Here's what each approach does:

1. **Array.includes**: This method returns `true` if the specified value (in this case, 99999) is present in the array, and `false` otherwise.
2. **Set.has**: This method returns `true` if the specified value (in this case, 99999) is present in the Set, and `false` otherwise. Sets are similar to arrays but only store unique values.
3. **Map.has**: This method returns `true` if the specified key (in this case, 99999) is present in the Map, and `false` otherwise.

Now, let's discuss the pros and cons of each approach:

* **Array.includes**:
	+ Pros: Easy to understand and implement, widely supported across browsers.
	+ Cons: Has a time complexity of O(n), where n is the size of the array. This means that as the array grows, the lookup time increases linearly.
* **Set.has**:
	+ Pros: Faster lookup times compared to `Array.includes` since Sets only store unique values and can use a hash table for efficient lookups (O(1) on average).
	+ Cons: Requires creating a Set object, which might incur additional overhead. Not all browsers support Sets natively, although most modern ones do.
* **Map.has**:
	+ Pros: Similar to Set.has, with the added benefit that Maps can store arbitrary values as keys (including non-unique values). This can be beneficial in certain scenarios.
	+ Cons: Requires creating a Map object, which might incur additional overhead. Not all browsers support Maps natively, although most modern ones do.

In the context of this benchmark, it's clear that Set.has and Map.has are significantly faster than Array.includes for large datasets like the one used here (100,000 elements). This is because Sets and Maps use hash tables for efficient lookups, which allows for constant-time performance even with very large datasets.

The difference in performance between Set.has and Map.has might seem minor at first glance, but it's essential to consider that Maps can store additional data as keys, while Sets are limited to storing unique values only. This means that if you need to perform lookups on a specific property of the key (like in the case of Array.includes), one of these approaches might be more suitable.

As for special JavaScript features or syntax, this benchmark doesn't explicitly use any advanced features beyond what's already discussed above.

Other alternatives to consider:

* **Using regular expressions**: Instead of using `includes()` or Set/Map lookups, you could use regular expressions to search for a specific value in the array or Map. This would likely be slower than the approaches used here but can provide more flexibility.
* **Using `Array.prototype.find()` and its variants**: If you're dealing with an array and need to find the first occurrence of a specific value, you might consider using `Array.prototype.find()`. This method returns the first element that satisfies the provided callback function. However, it has its own performance characteristics and might not be as efficient as Set.has or Map.has for large datasets.
* **Using native WebAssembly (WASM) optimizations**: If you're targeting a specific platform like WebAssembly-based browsers, you can explore using WASM to optimize your code for better performance. This would likely involve rewriting the benchmark in a WASM-specific language and compiling it into a Wasm binary.

Keep in mind that these alternatives might not be suitable for all use cases or platforms, so it's essential to consider the specific requirements of your project when choosing an approach.

Related benchmarks:

set.has vs. array.includes vs. map.has (version: 0)

Comparing performance of: Array.includes vs Set.has vs Map.has

Created: one year ago by: Guest

Jump to the latest result

Array.includes

Set.has

Map.has

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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