Benchmark: Array vs Set inclusion - 4

Script Preparation code:

var arrToCheck = Array.from(Array(1000).keys())
var setToCheck = new Set(arrToCheck)

Tests:

Array - 1
arrToCheck.includes(1)
Array - 2
arrToCheck.includes(500)
Set - 1
var s = new Set(arrToCheck) s.has(1)
Set - 2
var s = new Set(arrToCheck) s.has(500)
Set only - 1
setToCheck.has(1)
Set only - 2
setToCheck.has(500)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array - 1
Array - 2
Set - 1
Set - 2
Set only - 1
Set only - 2

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark definition is a JSON object that contains information about the test case. In this case, there are two main variables being compared:

1. `arrToCheck` which is an array created from another array using `Array.from()`.
2. `setToCheck` which is a set created from the same array.

**Options Compared**

The options being compared are:

1. Using `includes()` method on the array (`arrToCheck.includes(1)` and `arrToCheck.includes(500)`).
2. Using the `has()` method on the set (`s.has(1)` and `s.has(500)`).
3. Directly accessing elements in the set using its index (e.g., `setToCheck[0]`).

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Array includes()**: This is a simple and efficient way to check if an element exists in an array. However, it has to iterate through the entire array, which can be slow for large datasets.
2. **Set has()**: Using the `has()` method on a set is generally faster than using `includes()` on an array because sets are optimized for fast lookups. However, creating a set from a large array can be memory-intensive.
3. **Direct access**: Directly accessing elements in a set by their index is not recommended as it can lead to out-of-bounds errors.

**Library and Purpose**

The `Array.from()` method is a polyfill for the `from` keyword introduced in ECMAScript 2015 (ES6). It creates a new array from an iterable source, such as another array or an array-like object.

The `Set` constructor is a native JavaScript object that allows you to create a set data structure, which is essentially an unordered collection of unique values.

**Special JS Features/Syntax**

This benchmark does not use any special JS features or syntax. It only uses standard ECMAScript 2015 (ES6) syntax and methods.

**Other Alternatives**

If you want to compare the performance of these approaches on a different platform, you could consider using other JavaScript engines like Node.js, Firefox, or Safari. Additionally, you could also test with larger datasets or use more complex scenarios to put the benchmarking process under greater stress.

In terms of alternative libraries, if you wanted to use a third-party library for set operations, some popular options include:

* Lodash's `set` function
* Moment.js's `set` method (although primarily used for date manipulation)
* A library like [fast-set](https://github.com/joshmarquis/fast-set) which is designed specifically for fast set operations.

Latest run results:

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

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

Browser/OS: Chrome 102 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array - 1	26812268.0 Ops/sec
Array - 2	27091318.0 Ops/sec
Set - 1	49142.3 Ops/sec
Set - 2	50028.4 Ops/sec
Set only - 1	22283828.0 Ops/sec
Set only - 2	19322270.0 Ops/sec

Related benchmarks:

Array vs Set inclusion - 4 (version: 1)

Comparing performance of: Array - 1 vs Array - 2 vs Set - 1 vs Set - 2 vs Set only - 1 vs Set only - 2

Created: 2 years ago by: Registered User

Jump to the latest result

Array - 1

Array - 2

Set - 1

Set - 2

Set only - 1

Set only - 2

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