Benchmark: set.has vs. array.includes 1M

Script Preparation code:

var a = [];
for (var i = 0; i < 1E6; i++)
  a[i] = i;
var b = new Set(a)

Tests:

includes
return a.includes(9E5)
lookup
return b.has(9E5)

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:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and its components, explaining what's being tested and the options compared.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark for testing two approaches to check if an element exists in a set or array: `set.has()` vs `array.includes`.

**Script Preparation Code**

The script preparation code creates two variables:

* `a`: An empty array with 1 million elements, each assigned a unique value using the loop.
* `b`: A new Set object initialized with the values from `a`.

**Options Compared**

Two test cases are compared:

1. **includes**: This test case checks if an element exists in the array `a` using the `array.includes()` method.
2. **lookup**: This test case checks if an element exists in the set `b` using the `set.has()` method.

**Approaches Compared**

Both approaches have their pros and cons:

* **Array Includes (`includes`)**:
	+ Pros: Widely supported, easy to understand, and often used in code.
	+ Cons: Can be slower than Set methods for large datasets due to its linear search algorithm.
* **Set has (`lookup`)**:
	+ Pros: Generally faster than array includes for large datasets, thanks to the hash table data structure used by Sets.
	+ Cons: May require more memory and is less intuitive than `array.includes()`.

**Library Used**

The library used in this benchmark is JavaScript itself, with no external libraries required. However, the Set data structure is a built-in JavaScript feature that provides fast and efficient way to store unique values.

**Special JS Feature/ Syntax**

This benchmark doesn't rely on any special JavaScript features or syntax. It only uses standard JavaScript methods and data structures.

**Other Alternatives**

For sets, you could use other libraries like Lodash's `new Set()` function or the `Set` class from the TypeScript library. For arrays, you might consider using a data structure like a hash table or a trie for faster lookups.

Keep in mind that these alternatives are not necessarily necessary for this specific benchmark, as JavaScript's built-in Set and array methods provide sufficient performance for most use cases.

Related benchmarks:

set.has vs. array.includes 1M (version: 0)

Comparing performance of: includes vs lookup

Created: 3 years ago by: Guest

Jump to the latest result

includes

lookup

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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