Benchmark: includes vs has - MeasureThat.net

Tests:

includes
const array = [1, 2, 3]; const hasValue = value => array.includes(value); hasValue(1); hasValue(2); hasValue(3);
has
const set = new Set([1, 2, 3]); const hasValue = value => set.has(value); hasValue(1); hasValue(2); hasValue(3);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
has

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 JavaScript performance is a fascinating topic!

Let's dive into the provided benchmark.

**Benchmark Overview**

The benchmark compares two approaches for checking if a value exists in an array: `includes()` and `has()`. The test cases are designed to measure the execution time of these methods on both arrays and sets.

**Includes vs. Has**

### Includes

`includes()` is a method that checks if an element with the specified value exists in the array. It returns `true` if the element is found, and `false` otherwise.

Pros:

* Widely supported by most JavaScript engines.
* Can be used on arrays of any type (primitive values, objects, etc.).

Cons:

* May iterate over the entire array for each check, resulting in O(n) time complexity.
* Can be slower than other approaches for large datasets.

### Has

`has()` is a method that checks if an element with the specified value exists in the set. It returns `true` if the element is found, and `false` otherwise.

Pros:

* Typically faster than `includes()`, especially for sets, since it uses a hash table lookup.
* Designed specifically for sets, which can provide better performance than arrays.

Cons:

* Less widely supported by JavaScript engines compared to `includes()` (although becoming more common).
* May not work on all types of sets (e.g., arrays).

**Library Usage**

In the provided benchmark, the `Set` object is used in one of the test cases (`has`). The `Set` library is a built-in JavaScript API that provides efficient data structures for storing unique values. Its primary purpose is to:

* Provide fast membership testing (`has()`) and insertion/removal operations.
* Offer an alternative to arrays or objects when dealing with large amounts of unique data.

**Special JS Feature**

There is no special JavaScript feature or syntax explicitly used in this benchmark, but note that the use of `const` and arrow functions (`=>`) are modern JavaScript features introduced in ECMAScript 2015 (ES6).

**Other Alternatives**

Some alternative approaches for checking if a value exists in an array or set include:

* Using `indexOf()` on arrays, which returns -1 if not found.
* Implementing a custom search algorithm using loops and bitwise operations.
* Utilizing other data structures like trees or graphs to store the data.

However, these alternatives are often less efficient, more complex to implement, or may not be supported by all JavaScript engines.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36 Edg/83.0.478.45

Browser/OS: Chrome 83 on Windows

View result in a separate tab

Test name	Executions per second
includes	166890352.0 Ops/sec
has	3176997.5 Ops/sec

Related benchmarks:

includes vs has (version: 0)

Comparing performance of: includes vs has

Created: 4 years ago by: Guest

Jump to the latest result

includes

has

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