Benchmark: Set.has vs Array.includes Large Collections

Tests:

Set.has (1,000 items)
const myArray = []; for (let i = 0; i < 1000; i++) { myArray.push(i); } const mySet = new Set(myArray); const contains = mySet.has(999);
Array.includes (1,000 items)
const myArray = []; for (let i = 0; i < 1000; i++) { myArray.push(i); } const mySet = new Set(myArray); const contains = myArray.includes(i) ? true : false;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Set.has (1,000 items)
Array.includes (1,000 items)

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.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The provided JSON represents a benchmark definition, which outlines the test case and its requirements. In this case, we have two individual test cases:

1. `Set.has (1,000 items)`: This test case measures the performance of the `has` method on a large set.
2. `Array.includes (1,000 items)`: This test case measures the performance of the `includes` method on an array.

**Options Compared**

The two options being compared are:

1. **Set.has**: A method that checks if a specific value exists in a set.
2. **Array.includes**: A method that checks if a specific value exists in an array.

Both methods have different implementations and usage patterns, which affect their performance.

**Pros and Cons of Each Approach**

Here's a brief summary:

* **Set.has**:
	+ Pros: Generally faster than `Array.includes` for large datasets, as it uses a hash table to store the elements.
	+ Cons: Can be slower for small datasets or when the set is not fully populated, as it needs to iterate over all elements to check if they exist.
* **Array.includes**:
	+ Pros: Faster and more efficient for small datasets or when the array is partially populated, as it only needs to find the first occurrence of the value.
	+ Cons: Can be slower for large datasets, as it needs to iterate over all elements to find the value.

**Library**

Neither `Set.has` nor `Array.includes` relies on a specific library. They are built-in methods in JavaScript, which means they are available without any additional dependencies.

**Special JS Feature or Syntax**

There is no special feature or syntax being used in these test cases. The code is straightforward and uses standard JavaScript features.

**Other Alternatives**

If you're interested in exploring alternative approaches or libraries for set operations, here are a few options:

* **MathLib**: A lightweight library that provides additional mathematical functions, including some set-related operations.
* **Set.js**: A small library that provides an implementation of the `Set` interface, which can be useful if you need more control over set behavior.

However, please note that these alternatives might not offer significant performance improvements or changes in behavior compared to built-in methods like `has` and `includes`.

Keep in mind that MeasureThat.net's focus is on comparing the performance of built-in JavaScript methods across different browsers and environments. If you're interested in exploring more advanced set operations or libraries, there are many other resources available online.

Related benchmarks:

Set.has vs Array.includes Large Collections (version: 0)

Comparing performance of: Set.has (1,000 items) vs Array.includes (1,000 items)

Created: 4 years ago by: Guest

Jump to the latest result

Set.has (1,000 items)

Array.includes (1,000 items)

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