Benchmark: set.has vs. array.includes(million)

Script Preparation code:

var a = new Array(10000).map((item,index)=>index);
var b = new Set(a)

Tests:

includes
return a.includes(9999)
lookup
return b.has(9999)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
lookup

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its options.

**Benchmark Definition**

The benchmark is designed to compare two methods for checking if an element exists in a large array (`a`) or a set (`b`): `array.includes()` vs `set.has()`.

**Options Compared**

There are two options compared:

1. **Array.includes()**: This method checks if an element exists in the array by iterating through its elements and checking for a match.
2. **Set.has()**: This method checks if an element exists in the set by using a hash table data structure to store unique values.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Array.includes()**:
	+ Pros: Easy to implement, works well for small arrays.
	+ Cons: Slow for large arrays due to linear search, may be optimized away in some browsers.
* **Set.has()**:
	+ Pros: Fast for large datasets, uses a hash table data structure for efficient lookups.
	+ Cons: Requires creating a set from the array, which can be slower than initializing an empty array.

**Library**

In this benchmark, `Set` is used as a library to create a set from the array. The `Set` constructor takes an iterable (in this case, an array) and automatically adds each unique element to the set.

**Special JS Feature/Syntax**

This benchmark uses none of any special JavaScript features or syntax beyond standard ES6/ES7 syntax. It's designed to be run in a variety of browsers with different levels of support for modern features.

**Other Considerations**

* The benchmark is designed to measure performance, so it's essential to consider factors like cache locality and branch prediction when interpreting the results.
* The test cases are written to exercise specific aspects of each method, ensuring that the comparison is fair and representative.

**Alternatives**

If you wanted to explore alternative approaches or testing scenarios:

1. Compare `includes()` with a custom implementation using binary search or other optimized algorithms.
2. Test `has()` against other set operations like `delete()` or `size()`.
3. Use different data distributions (e.g., random numbers, strings) for the test array or set.

Keep in mind that these alternatives would require adjustments to the benchmark definition and script preparation code.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:90.0) Gecko/20100101 Firefox/90.0

Browser/OS: Firefox 90 on Ubuntu

View result in a separate tab

Test name	Executions per second
includes	48145.5 Ops/sec
lookup	35394392.0 Ops/sec

Related benchmarks:

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

Comparing performance of: includes vs lookup

Created: 3 years ago by: Registered User

Jump to the latest result

includes

lookup

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