Benchmark: JS includes vs set

Script Preparation code:

var arr = Array.from({ length: 1000000 }, (_, i) => i);
var set = new Set(arr);

Tests:

includes
arr.includes(987654);
set
set.has(987654)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
set

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the JavaScript microbenchmark on MeasureThat.net.

**Benchmark Definition**

The benchmark is designed to test the performance difference between using `includes()` and checking for existence in an array (or set) using the `has()` method.

**Options Compared**

Two options are being compared:

1. **`arr.includes(987654)`**: This option uses the built-in `includes()` method to check if a specific value (`987654`) exists in the array `arr`.
2. **`set.has(987654)`**: This option uses the `has()` method of a Set object, which is essentially an unordered collection of unique values.

**Pros and Cons**

Here's a brief analysis of each approach:

### `arr.includes(987654)`

Pros:

* Easy to read and write
* Widely supported in modern browsers

Cons:

* Can be slower for large arrays because it has to iterate over the entire array to find the value.
* May not be as efficient as using a Set or other data structure specifically designed for fast lookup.

### `set.has(987654)`

Pros:

* Extremely fast for large datasets, as sets use a hash table for lookup.
* Memory-efficient, as sets only store unique values.

Cons:

* Requires creating a Set object and passing in the array to create it.
* May be less readable than using `includes()` for some developers.

**Library/Technology**

The `Set` data structure is a built-in JavaScript library. It's an unordered collection of unique values that allows you to add, remove, and test existence of elements efficiently.

**Special JS Feature/Syntax**

There are no specific special features or syntax used in this benchmark other than the use of `includes()` and `has()`, which are standard methods in modern JavaScript.

**Other Alternatives**

If you need faster lookup performance than using a Set, you could consider alternative data structures like:

* Arrays with binary search (for large datasets)
* Hash tables (e.g., `Map` object in JavaScript)
* Other data structures designed for fast lookup, such as Tries or suffix trees

However, these alternatives might require additional code and are not as widely supported as using a Set.

In summary, the benchmark tests the performance difference between using `includes()` and checking for existence in an array (or set) using the `has()` method. The `set.has(987654)` option is significantly faster for large datasets due to its use of a hash table, but requires creating a Set object and passing in the array.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36

Browser/OS: Chrome 106 on Windows

View result in a separate tab

Test name	Executions per second
includes	83516.9 Ops/sec
set	24065784.0 Ops/sec

Related benchmarks:

JS includes vs set (version: 0)

Comparing performance of: includes vs set

Created: 2 years ago by: Registered User

Jump to the latest result

includes

set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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