Benchmark: Array includes vs Set.has

Script Preparation code:

var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

Tests:

includes
return a.includes(9);
Set.has
var b = new Set(a); return b.has(9);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
Set.has

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 16_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 16 on iOS 16.1.1

View result in a separate tab

includes

10.9M/s

Set.has

1.9M/s

View exact numbers

Test name	Executions per second
✓ includes	10,899,384 Ops/sec
Set.has	1,941,320 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what is being tested on the MeasureThat.net website.

**Benchmark Definition**

The benchmark definition is a JSON object that contains information about the test case being run. In this case, it defines two test cases:

1. `Array includes vs Set.has`
2. Two individual test cases:
	* `includes`: Tests if an array (`a`) contains a specific element (9) using the `includes` method.
	* `Set.has`: Tests if a set (`b`) created from the same array (`a`) contains the same element (9) using the `has` method of sets.

**Options being compared**

In this benchmark, two options are being compared:

1. **Array includes**: Using the `includes` method on an array to check for membership.
2. **Set has**: Using a Set data structure to store unique elements and checking if that set contains a specific element using the `has` method.

**Pros and Cons of each approach**

Here's a brief overview of the pros and cons of each approach:

1. **Array includes**
	* Pros:
		+ Lightweight and easy to implement.
		+ Fast lookup times in modern browsers.
	* Cons:
		+ Can be slower for very large arrays due to the overhead of iterating over elements.
		+ May not be as efficient as sets for unique element storage.
2. **Set has**
	* Pros:
		+ More efficient than arrays for storing and looking up unique elements.
		+ Fast lookup times on average (O(1) time complexity).
	* Cons:
		+ Requires the creation of a new Set object, which can be slower than just using `includes`.
		+ May not be suitable for all use cases, as Sets are designed to store unique values and may not preserve order.

**Library and its purpose**

In this benchmark, no external libraries are used. However, it's worth noting that the `Set` data structure is a native JavaScript feature that was introduced in ECMAScript 2015 (ES6).

**Special JS features or syntax**

There are no special JS features or syntax mentioned in the benchmark definition or individual test cases.

**Other alternatives**

If you needed to compare other approaches, some alternative options could be:

* Using `indexOf` instead of `includes`
* Using `Array.prototype.findIndex` instead of `includes`
* Comparing performance using different data structures, such as linked lists or trees
* Examining the performance of different algorithms for finding elements in an array (e.g., binary search)

These alternatives would likely require additional modifications to the benchmark definition and individual test cases.

Array includes vs Set.has (version: 0)

Comparing performance of: `includes vs Set.has`

Created: 2 years ago by: Guest

Go to the latest result

includes

Set.has

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Array includes vs Set.has (version: 0)

Comparing performance of: includes vs Set.has

Created: 2 years ago by: Guest

Go to the latest result

includes

Set.has

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `includes vs Set.has`