Benchmark: Set#has() vs Array#includes()

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36

Browser/OS: Chrome 128 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
const array = [1, 2, 3]; const hasValue = value => array.includes(value);	407154.8 Ops/sec
const set = new Set([1, 2, 3]); const hasValue = value => set.has(value);	384482.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is being tested?**

The provided benchmark tests two approaches to check if a value exists in an array or a Set data structure:

1. `array.includes(value)`
2. `set.has(value)`

These functions are used to determine whether a specific value (`value`) is present in the given array or Set.

**Options compared:**

There are two options being compared:

1. **Array**: An ordered collection of unique values, which provides fast lookup times.
2. **Set**: An unordered collection of unique values, which also provides fast lookup times but with some differences in behavior compared to arrays.

**Pros and Cons of each approach:**

**Array (includes())**

Pros:

* Fast and efficient for large datasets
* Provides a clear and intuitive way to check for existence

Cons:

* May have slower performance for very small datasets due to the overhead of searching through the entire array
* Can be more memory-intensive than Sets, especially for large datasets

**Set (has())**

Pros:

* Often faster than arrays for small to medium-sized datasets
* Provides a clear and intuitive way to check for existence
* Can be more memory-efficient than arrays, especially for large datasets with many duplicates

Cons:

* May have slower performance for very large datasets due to the overhead of maintaining the Set's internal data structure
* May not provide as much information about the dataset (e.g., its size or elements) as an array would.

**Library/Function Used:**

In both test cases, `array.includes(value)` and `set.has(value)` are used. These functions are native to JavaScript and do not require any additional libraries.

**Special JS Features/Syntax:**

None of the provided benchmark test cases utilize special JavaScript features or syntax. They are straightforward examples that demonstrate a simple comparison between two approaches.

**Other Alternatives:**

For more complex use cases, other data structures like Maps (JavaScript objects) could be used as alternatives to arrays and Sets. However, these would likely require additional libraries or modifications to the existing code.

In summary, this benchmark tests the performance difference between using `array.includes(value)` versus `set.has(value)` for small datasets. It provides a useful comparison of two approaches that can help developers make informed decisions about which data structure to use in their applications.

Related benchmarks:

Set#has() vs Array#includes() (version: 0)

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

Created: 3 months ago by: Guest

Jump to the latest result

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

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

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