Benchmark: Set.has v.s Array.includes v2

Script Preparation code:

function getRandomInt(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

function createRandomIntArray(maxLength) {
    const randomArray = [];

    for (let i = 0; i < maxLength; i++) {
        const randomInt = i;
        randomArray.push(i);
    }
    return randomArray;
}

function createTargetArray(maxLength, maxValue) {
    const randomArray = [];

    for (let i = 0; i < maxLength-1; i++) {
        const randomInt = i;
        randomArray.push(10001+i);
    }
    randomArray.push(maxValue);
    return randomArray;
}

var ids1 = createRandomIntArray(100);
var ids2 = createRandomIntArray(1000);
var ids3 = createRandomIntArray(10000);

var target1 = createTargetArray(100, 99);
var target2 = createTargetArray(1000, 999);
var target3 = createTargetArray(10000, 9999);

​x
 
function getRandomInt(min, max) {    return Math.floor(Math.random() * (max - min + 1)) + min;}​function createRandomIntArray(maxLength) {    const randomArray = [];​    for (let i = 0; i < maxLength; i++) {        const randomInt = i;        randomArray.push(i);    }    return randomArray;}​function createTargetArray(maxLength, maxValue) {    const randomArray = [];​    for (let i = 0; i < maxLength-1; i++) {        const randomInt = i;        randomArray.push(10001+i);    }    randomArray.push(maxValue);    return randomArray;}​var ids1 = createRandomIntArray(100);var ids2 = createRandomIntArray(1000);var ids3 = createRandomIntArray(10000);​var target1 = createTargetArray(100, 99);var target2 = createTargetArray(1000, 999);var target3 = createTargetArray(10000, 9999);

Tests:

set

var idsSet1 = new Set(ids1)
target1.some(id => idsSet1.has(id))

var idsSet2 = new Set(ids2)
target2.some(id => idsSet2.has(id))

var idsSet3 = new Set(ids3)
target3.some(id => idsSet3.has(id))

 
var idsSet1 = new Set(ids1)target1.some(id => idsSet1.has(id))​var idsSet2 = new Set(ids2)target2.some(id => idsSet2.has(id))​var idsSet3 = new Set(ids3)target3.some(id => idsSet3.has(id))

array
target1.some(id => ids1.includes(id)) target2.some(id => ids2.includes(id)) target3.some(id => ids3.includes(id))
target1.some(id => ids1.includes(id))
target2.some(id => ids2.includes(id))
target3.some(id => ids3.includes(id))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
set
array

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

Browser/OS: Chrome 115 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
set	1738.1 Ops/sec
array	89.2 Ops/sec

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

Let's break down what's being tested in this benchmark.

Benchmark Definition

The benchmark is comparing two methods to check if an element exists in an array or a Set:

Set.has() method
Array.includes() method (specifically, the new version of includes() introduced in ECMAScript 2020, which allows passing a callback function).

Script Preparation Code

The script preparation code generates three arrays with random integers and one array with a target value. The arrays are created using two functions:

createRandomIntArray(maxLength): creates an array with maxLength elements, where each element is a random integer between 0 and maxLength - 1.
createTargetArray(maxLength, maxValue): creates an array with maxLength elements, where the last element is set to maxValue.

Benchmark Definition Json

The benchmark definition json contains two test cases:

"set": This test case uses the Set.has() method to check if each element in the arrays exists in the Set.
"array": This test case uses the new version of Array.includes() to check if each element in the arrays exists.

Options Compared

The benchmark is comparing two options:

Using Set.has() to check for existence
Using the new version of Array.includes() with a callback function

Pros and Cons

Using Set.has():

Pros:
- Faster lookup times compared to Array.includes()
- More memory-efficient, as Sets only store unique values
Cons:
- May not be suitable for large datasets or arrays with many duplicate values
- May require additional setup or modifications to work correctly

Using the new version of Array.includes() with a callback function:

Pros:
- More flexible and adaptable than Set.has(), as it can handle more complex conditions
- May be easier to understand and maintain, especially for developers familiar with functional programming concepts
Cons:
- Slower lookup times compared to Set.has()
- May consume more memory, especially if the callback function is complex or recursive

Library Used

The benchmark uses the JavaScript Set data structure, which is a collection of unique values. The Set data structure provides an efficient way to check for existence using the has() method.

Special JS Feature/Syntax

There are no special JavaScript features or syntax used in this benchmark, aside from the new version of Array.includes() introduced in ECMAScript 2020.

Other Alternatives

If you're interested in exploring alternative methods for checking existence in arrays or Sets, here are a few options:

Using Object.prototype.hasOwnProperty.call(): This method can be used to check if an element exists in an array or object, but it may not be the most efficient or readable solution.
Using a library like Lodash: This library provides a variety of utility functions for working with arrays and objects, including methods for checking existence.

Keep in mind that the choice of method will depend on your specific use case and performance requirements.

LLMs can make mistakes. Check important info.

Let's break down what's being tested in this benchmark.

**Benchmark Definition**

The benchmark is comparing two methods to check if an element exists in an array or a Set:

1. `Set.has()` method
2. `Array.includes()` method (specifically, the new version of `includes()` introduced in ECMAScript 2020, which allows passing a callback function).

**Script Preparation Code**

The script preparation code generates three arrays with random integers and one array with a target value. The arrays are created using two functions:

* `createRandomIntArray(maxLength)`: creates an array with `maxLength` elements, where each element is a random integer between 0 and `maxLength - 1`.
* `createTargetArray(maxLength, maxValue)`: creates an array with `maxLength` elements, where the last element is set to `maxValue`.

**Benchmark Definition Json**

The benchmark definition json contains two test cases:

1. "set": This test case uses the `Set.has()` method to check if each element in the arrays exists in the Set.
2. "array": This test case uses the new version of `Array.includes()` to check if each element in the arrays exists.

**Options Compared**

The benchmark is comparing two options:

1. Using `Set.has()` to check for existence
2. Using the new version of `Array.includes()` with a callback function

**Pros and Cons**

**Using `Set.has()`:**

* Pros:
	+ Faster lookup times compared to `Array.includes()`
	+ More memory-efficient, as Sets only store unique values
* Cons:
	+ May not be suitable for large datasets or arrays with many duplicate values
	+ May require additional setup or modifications to work correctly

**Using the new version of `Array.includes()` with a callback function:**

* Pros:
	+ More flexible and adaptable than `Set.has()`, as it can handle more complex conditions
	+ May be easier to understand and maintain, especially for developers familiar with functional programming concepts
* Cons:
	+ Slower lookup times compared to `Set.has()`
	+ May consume more memory, especially if the callback function is complex or recursive

**Library Used**

The benchmark uses the JavaScript `Set` data structure, which is a collection of unique values. The Set data structure provides an efficient way to check for existence using the `has()` method.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntax used in this benchmark, aside from the new version of `Array.includes()` introduced in ECMAScript 2020.

**Other Alternatives**

If you're interested in exploring alternative methods for checking existence in arrays or Sets, here are a few options:

* Using `Object.prototype.hasOwnProperty.call()`: This method can be used to check if an element exists in an array or object, but it may not be the most efficient or readable solution.
* Using a library like Lodash: This library provides a variety of utility functions for working with arrays and objects, including methods for checking existence.

Keep in mind that the choice of method will depend on your specific use case and performance requirements.

Related benchmarks:

Set.has v.s Array.includes v2 (version: 0)

Comparing performance of: set vs array

Created: one year ago by: Guest

Jump to the latest result

set

array

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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