Benchmark: Set x includes x includes (lodash) (comparing first middle and last and not existing)

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var arr = Array.from(Array(100000).keys());
var set = new Set(arr);

Tests:

set middle
set.has(50000);
includes middle
arr.includes(50000);
set begin
set.has(1);
includes begin
arr.includes(50000);
includes end
arr.includes(99999);
set end
set.has(99999);
set does not exists
set.has(-1);
includes does not exists
arr.includes(-1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
set middle
includes middle
set begin
includes begin
includes end
set end
set does not exists
includes does not exists

Fastest: N/A

Slowest: N/A

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/116.0.0.0 Safari/537.36

Browser/OS: Chrome 116 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
set middle	35189132.0 Ops/sec
includes middle	35451716.0 Ops/sec
set begin	34804684.0 Ops/sec
includes begin	34965120.0 Ops/sec
includes end	35306108.0 Ops/sec
set end	35109372.0 Ops/sec
set does not exists	35220988.0 Ops/sec
includes does not exists	35114080.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and analyze what is being tested, compared, and their pros and cons.

**Benchmark Test**

The benchmark measures the execution speed of three different approaches to check if an element exists in a Set data structure:

1. `set.has(50000)`: Checking if 50,000 is present in the set.
2. `arr.includes(50000)`: Checking if 50,000 is present in the array.
3. `set.has(1)`: Checking if 1 is present in the set.
4. `arr.includes(1)`: Checking if 1 is present in the array.
5. `arr.includes(99999)`: Checking if 99,999 is present in the array (end case).
6. `set.has(99999)`: Checking if 99,999 is present in the set (end case).
7. `set.has(-1)`: Checking if -1 is not present in the set (does not exists).
8. `arr.includes(-1)`: Checking if -1 is not present in the array (does not exists).

**Options Compared**

The benchmark compares the execution speed of two options:

* Using a Set data structure (`set.has()`) vs.
* Using an array method (`includes()`)

**Pros and Cons**

**Using a Set Data Structure:**

Pros:

* Sets are designed for fast membership testing, making them suitable for this use case.
* They have an average time complexity of O(1), which means the lookup time is constant, regardless of the size of the set.

Cons:

* Sets require more memory to store the elements compared to arrays.
* Insertion and deletion operations can be slower due to the hashing mechanism used.

**Using an Array Method:**

Pros:

* Arrays are more familiar and widely supported in JavaScript, making them easier to implement and debug.
* They provide a simpler and more intuitive way to perform membership testing.

Cons:

* The time complexity of `includes()` is O(n), which means it scales linearly with the size of the array. This can lead to slower performance for large datasets.

**Other Considerations**

* Using `Array.from()` and `Set` constructors can introduce additional overhead due to the creation of new objects.
* The benchmark script preparation code includes `var arr = Array.from(Array(100000).keys());`, which creates a large array of 100,000 elements. This can impact performance.

**Libraries and Special Features**

The benchmark uses Lodash's `lodash.min.js` library, which provides the `has()` method for sets. The script preparation code includes an import statement to load this library.

There are no special JavaScript features or syntax used in the benchmark.

**Alternatives**

If you want to implement a similar benchmark using another data structure, such as a Map, you can use its `has()` method instead of Set's `has()`. If you prefer to stick with arrays, you can use other array methods like `indexOf()` or `findIndex()` for membership testing.

Keep in mind that the choice of data structure and implementation details will significantly impact the performance characteristics of your code.

Related benchmarks:

Set x includes x includes (lodash) (comparing first middle and last and not existing) (version: 0)

Comparing performance of: set middle vs includes middle vs set begin vs includes begin vs includes end vs set end vs set does not exists vs includes does not exists

Created: 4 years ago by: Guest

Jump to the latest result

set middle

includes middle

set begin

includes begin

includes end

set end

set does not exists

includes does not exists

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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