Benchmark: set.has vs. array.includes (find 999,999 in 1,000,000)

Script Preparation code:

var a = Array.from({length: 1000000}, (val, index) => index);
var b = new Set(a)

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
lookup

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 151 on Linux

View result in a separate tab

Test name	Executions per second
includes	1005.2 Ops/sec
lookup	2024766976.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested on this specific benchmark.

**Benchmark Overview**

The provided JSON represents two test cases: `lookup` and `includes`. Both tests aim to measure the performance difference between using a `Set` data structure (with the `has` method) versus an array (with the `includes` method) for searching a large dataset containing 1 million elements, one of which is 999,999.

**Options Compared**

The two options being compared are:

1. **Lookup (Set)**: Using the `has` method on a `Set` data structure to search for an element. A `Set` in JavaScript is a collection of unique values, and the `has` method checks if a value exists within it.
2. **Includes (Array)**: Using the `includes` method on an array to search for an element.

**Pros and Cons**

* **Lookup (Set)**:
	+ Pros:
		- Fast lookup times, as sets use a hash table implementation under the hood.
		- Efficient for large datasets, as set operations are typically faster than array operations.
	+ Cons:
		- Requires an extra step to create the set from the array.
		- May require additional memory allocation if the set is larger than the original array.
* **Includes (Array)**:
	+ Pros:
		- Simpler implementation, as it only requires a linear search through the array.
		- Does not require creating an extra data structure (set).
	+ Cons:
		- Slower lookup times compared to sets, especially for large datasets.
		- May be slower if the dataset is sparse or has many duplicates.

**Library and Purpose**

No specific libraries are used in this benchmark. However, it's worth noting that some JavaScript engines, like SpiderMonkey (used by Firefox), use optimized implementations of set operations under the hood.

**Special JS Feature/Syntax**

None explicitly mentioned in the provided code snippets. However, it's essential to mention that modern JavaScript engines often use various optimization techniques, such as:

* **Caching**: Some engines may cache frequently accessed values or methods to improve performance.
* **Inlining**: Engine optimizations can inline functions to reduce overhead and improve execution efficiency.

**Alternatives**

Other alternatives for benchmarking set-based operations include:

1. **Array.prototype.indexOf()**: Similar to `includes`, but returns the index of the first occurrence instead of a boolean value.
2. **Object.prototype.hasOwnProperty()**: A method that checks if an object has a specific property, which can be used as a rough equivalent to the `has` method in sets.

For benchmarking array-based operations:

1. **Array.prototype.indexOf()` (mentioned above)
2. **Array.prototype.forEach()`: Although not directly comparable to `includes`, it demonstrates iteration and searching within an array.
3. **Array.prototype.map()` / **Array.prototype.filter()**: These methods can be used as benchmarks for specific use cases, such as data transformation or filtering.

Keep in mind that these alternatives might not provide the exact same results or optimization strategies as the original benchmark, but they can still offer valuable insights into performance differences between various JavaScript operations.

Related benchmarks:

set.has vs. array.includes (find 999,999 in 1,000,000) (version: 0)

Comparing performance of: includes vs lookup

Created: 2 years ago by: Guest

Jump to the latest result

includes

lookup

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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