Benchmark: .includes vs mass compare vs lookup

Script Preparation code:

function activeElementIsImportant1() {
        let activeElement = "someString";
        if (activeElement == 'someString11'
            || activeElement == '123'
            || activeElement == 'qeqw'
            || activeElement == 'qwewqdadas'
            || activeElement == 'someString1'
            || activeElement == 'someString12'
            || activeElement == 'asdqwwqd'
            || activeElement == 'asdadqw'
            || activeElement == 'xzczxaq'
            || activeElement == 'zxczx'
            || activeElement == '12321'
            || activeElement == 'qwewq'
            || activeElement == 'asdasdasdsa'
            || activeElement == 'czxcz'
            || activeElement == 'vbvbvb'
            || activeElement == 'wwww'
            || activeElement == '121'
            || activeElement == '12321312'
            || activeElement == 'zxzxzxzxzxzx'
            || activeElement == '3333') {
            return true;
        } else {
            return false;
        };
    };

const compareArray = ['someString11',
    '123',
    'qeqw',
    'qwewqdadas',
    'someString1',
    'someString12',
    'asdqwwqd',
    'asdadqw',
    'xzczxaq',
    'zxczx',
    '12321',
    'qwewq',
    'asdasdasdsa',
    'czxcz',
    'vbvbvb',
    'wwww',
    '121',
    '12321312',
    'zxzxzxzxzxzx',
    '3333'];

function activeElementIsImportant2() {
        if (compareArray.includes("someString")) {
            return true;
        } else {
            return false;
        };
    };

const lookup = new Map([
        ['someString11'],
        ['123'],
        ['qeqw'],
        ['qwewqdadas'],
        ['someString1'],
        ['someString12'],
        ['asdqwwqd'],
        ['asdadqw'],
        ['xzczxaq'],
        ['zxczx'],
        ['12321'],
        ['qwewq'],
        ['asdasdasdsa'],
        ['czxcz'],
        ['vbvbvb'],
        ['wwww'],
        ['121'],
        ['12321312'],
        ['zxzxzxzxzxzx'],
        ['3333']
    ]);
function activeElementIsImportant3() {
        if (lookup.has("someString")) {
            return true;
        } else {
            return false;
        };
    };

Tests:

mass compare
let k = activeElementIsImportant1();
array test
let k = activeElementIsImportant2();
lookup table
let k = activeElementIsImportant3();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
mass compare
array test
lookup table

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down what's being tested in the provided benchmark and explain the different approaches, their pros and cons, and other considerations.

**Benchmark Definition**

The benchmark is comparing three methods to check if a string exists in an array or map:

1. **Mass comparison**: Iterating over the entire array or map to find a match.
2. **Array test**: Using the `includes()` method to check if a value exists in an array.
3. **Lookup table**: Creating a map with key-value pairs and checking if a value is present in the map.

**Individual Test Cases**

Each test case has a different benchmark definition:

1. **Mass comparison**: The first test case uses the `activeElementIsImportant1()` function, which iterates over the entire `compareArray` array to find a match.
2. **Array test**: The second test case uses the `activeElementIsImportant2()` function, which uses the `includes()` method on the `compareArray` array.
3. **Lookup table**: The third test case uses the `activeElementIsImportant3()` function, which creates a map with key-value pairs and checks if the value is present in the map.

**Options Compared**

The three approaches are being compared to measure their performance:

* Mass comparison: This approach has the highest overhead due to iterating over the entire array or map.
* Array test: Using `includes()` method is generally faster than mass comparison, as it only requires a single pass through the array.
* Lookup table: Creating a lookup table (map) and checking if a value is present in it can be faster than array tests, especially for large datasets, since it allows for O(1) lookups.

**Pros and Cons**

* Mass comparison:
	+ Pros: Simple to implement, no additional data structure required.
	+ Cons: High overhead due to iterating over the entire array or map.
* Array test:
	+ Pros: Fast, efficient, and easy to implement.
	+ Cons: May not be suitable for large datasets or performance-critical applications.
* Lookup table:
	+ Pros: Can be faster than array tests for large datasets, allows for O(1) lookups.
	+ Cons: Requires additional memory and computational resources to create the lookup table.

**Other Considerations**

* The `includes()` method is optimized in modern browsers and can be faster than mass comparison or lookup tables.
* For very large datasets, using a more efficient data structure like a trie or a suffix tree might be necessary.
* The choice of approach depends on the specific use case, dataset size, and performance requirements.

**Library**

The `includes()` method is a built-in JavaScript function that checks if a value exists in an array. It's not a separate library, but rather a native part of the language.

**Special JS Feature or Syntax**

There are no special features or syntaxes used in this benchmark. The code is standard JavaScript, and the only notable feature is the use of `includes()` method for the array test.

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/99.0.4844.84 Safari/537.36 OPR/85.0.4341.72

Browser/OS: Opera 85 on Windows

View result in a separate tab

Test name	Executions per second
mass compare	10139062.0 Ops/sec
array test	10175180.0 Ops/sec
lookup table	10200261.0 Ops/sec

Related benchmarks:

.includes vs mass compare vs lookup (version: 0)

Comparing performance of: mass compare vs array test vs lookup table

Created: 2 years ago by: Guest

Jump to the latest result

mass compare

array test

lookup table

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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