Benchmark: Array vs Set inclusion - 2

Script Preparation code:

var arrToCheck = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
var setToCheck = new Set(arrToCheck)

Tests:

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

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 benchmark and explain what's being tested.

**Benchmark Definition JSON**

The benchmark definition JSON specifies two main components:

1. `arrToCheck` and `setToCheck`: These are arrays and sets, respectively, created from the same array of numbers (1-10). The purpose of creating these data structures is to test how different browsers perform when searching for an element within them.
2. `Script Preparation Code`: This section provides the JavaScript code used to create the `arrToCheck` and `setToCheck` variables.

**Test Cases**

The benchmark consists of six individual test cases, each testing a slightly different scenario:

1. Array - 1: Searching for an element (`10`) in the array.
2. Array - 2: Searching for an element (`1`) in the array.
3. Set - 1: Searching for an element (`10`) in the set.
4. Set - 2: Searching for an element (`1`) in the set.
5. Set only - 1: Searching for an element (`10`) in a new set created from `arrToCheck`.
6. Set only - 2: Searching for an element (`1`) in a new set created from `arrToCheck`.

**Options Compared**

The benchmark is comparing the performance of different approaches:

* Using the `includes()` method on arrays vs. using the `has()` method on sets.
* Creating a new set from an array and then searching for an element (Set only - 1 and Set only - 2) vs. directly searching for an element in the original array.

**Pros and Cons of Different Approaches**

Here are some pros and cons of each approach:

* Using `includes()` on arrays:
	+ Pros: Fast, widely supported, and easy to use.
	+ Cons: Can be slower than using `has()` on sets for large datasets.
* Using `has()` on sets:
	+ Pros: Generally faster than using `includes()` on arrays for large datasets.
	+ Cons: Less widely supported, may not work in older browsers or with certain types of data structures.
* Creating a new set from an array and then searching for an element (Set only - 1 and Set only - 2):
	+ Pros: Can be faster than directly searching in the original array for some use cases.
	+ Cons: Creates additional overhead, may not be necessary or optimal for all scenarios.

**Library**

In this benchmark, `Set` is a built-in JavaScript object that provides a fast and efficient way to store unique values. The `has()` method is used to test whether an element exists in the set.

**Special JS Feature/Syntax**

This benchmark does not use any special or proprietary JavaScript features or syntax. It only relies on standard JavaScript objects, methods, and data structures.

**Alternatives**

There are alternative approaches to testing performance comparisons like this one:

* Using a profiler or benchmarking tool to measure execution times in different scenarios.
* Implementing custom benchmarks using a test framework.
* Utilizing existing libraries or frameworks that provide optimized implementations for specific operations (e.g., searching).

Keep in mind that the choice of approach will depend on the specific requirements and goals of the project.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 108 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Array - 1	27655632.0 Ops/sec
Array - 2	27799014.0 Ops/sec
Set - 1	3644698.2 Ops/sec
Set - 2	3621408.5 Ops/sec
Set only - 1	27691342.0 Ops/sec
Set only - 2	27718816.0 Ops/sec

Related benchmarks:

Array vs Set inclusion - 2 (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: 3 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):