Benchmark: Better set.has vs array.includes

Better set.has vs array.includes (version: 0)

It often does not make sense to just compare only includes vs has. If we can not create the Set beforehand to be reused, and we need to initialize it every time, it will probably deteriorate the performance and we are better off using just simple include most of the times.

Comparing performance of: includes vs lookup

Created: 9 months ago by: Registered User

Jump to the latest result

Script Preparation code:

function generateRandomData(length) {
    const data = [];
    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

    for (let i = 0; i < length; i++) {
        let randomString = '';
        for (let j = 0; j < 20; j++) {
            randomString += characters.charAt(Math.floor(Math.random() * characters.length));
        }
        data.push({ value: randomString });
    }

    return data;
}

var data = generateRandomData(20);
var stringToBeChecked = data[15];

Tests:

includes
const a = data.map(x => x.value); return a.includes(stringToBeChecked);
lookup
const b = new Set(data.map(x => x.value)); return b.has(stringToBeChecked);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
includes
lookup

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 7 months ago)

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

Browser/OS: Chrome 121 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
includes	3932468.5 Ops/sec
lookup	615016.6 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 provided benchmark definition and test cases.

**Benchmark Definition**

The benchmark is designed to compare two approaches: using `array.includes()` vs using a `Set` data structure (`set.has()`). The goal is to determine which approach is more efficient, especially when the dataset needs to be initialized every time.

**Script Preparation Code**

The script preparation code generates random data for testing. It creates an array of objects with random strings as values and stores it in the `data` variable. The `stringToBeChecked` variable is set to the 16th element of this array.

**Html Preparation Code**

There is no HTML preparation code, which means that the test cases are running in a JavaScript environment without any additional web page context.

**Individual Test Cases**

The benchmark consists of two individual test cases:

1. **includes**: This test case uses `array.includes()` to search for the `stringToBeChecked` value within the `data` array.
2. **lookup**: This test case creates a new `Set` data structure from the `data` array and then uses `set.has()` to check if the `stringToBeChecked` value is present in the set.

**Library: Set**

The `Set` library is used in the second test case (`lookup`). A `Set` data structure is a collection of unique values that are ordered and cannot have duplicate keys. The `has()` method checks whether an element with the specified value exists in the set or not.

**Pros and Cons**

1. **array.includes()**:
	* Pros: Simple, widely supported, and easy to implement.
	* Cons: May be slower than using a `Set` data structure when dealing with large datasets or repeated values.
2. **set.has()**:
	* Pros: Can be faster than `array.includes()` for large datasets, especially if the dataset is unordered or contains duplicates.
	* Cons: Requires more code to create and manage the set.

**Other Considerations**

The benchmark may also take into account other factors that can affect performance, such as:

* JavaScript engine version and configuration
* Hardware platform and processor type
* Available memory and CPU resources

**Alternatives**

If you're interested in exploring alternative approaches, you could consider using:

1. **WeakSet**: A weak set is similar to a regular set but doesn't prevent the garbage collector from deleting the elements when they're no longer referenced.
2. **Map**: A map (also known as an object) can be used to store unique values and look them up efficiently.

However, these alternatives may not offer significant performance benefits over `Set` or `array.includes()` in this specific benchmark.

Related benchmarks: