Benchmark: Array Intersection Comparison

Array Intersection Comparison (version: 0)

Comparing performance of: intersect_for(shortArr1, shortArr2) vs intersect_filter_indexOf(shortArr1, shortArr2) vs intersect_filter_in(shortArr1, shortArr2) vs intersect_for_in(shortArr1, shortArr2) vs intersect_filter_includes(shortArr1, shortArr2) vs intersect_filter_has_this(shortArr1, shortArr2) vs intersect_filter_has_arrow(shortArr1, shortArr2) vs intersect_for_has(shortArr1, shortArr2)

Created: 5 years ago by: Guest

Jump to the latest result

Script Preparation code:

var shortSize = 100;
var longSize = 10000;

var shortArr1 = Array.from({
    length: shortSize
}, () => Math.floor(Math.random() * shortSize));
var shortArr2 = Array.from({
    length: shortSize
}, () => Math.floor(Math.random() * shortSize));

function intersect_for(a, b) {
    const result = [];
    const alen = a.length;
    const blen = b.length;
    for (let i = 0; i < alen; ++i) {
        const ai = a[i];
        for (let j = 0; j < blen; ++j) {
            if (ai === b[j]) {
                result.push(ai);
                break;
            }
        }
    }
    return result;
}

function intersect_filter_indexOf(a, b) {
    return a.filter(el => b.indexOf(el) !== -1);
}

function intersect_filter_in(a, b) {
    const map = b.reduce((map, el) => {
        map[el] = true;
        return map
    }, {});
    return a.filter(el => el in map);
}

function intersect_for_in(a, b) {
    const result = [];
    const map = {};
    for (let i = 0, length = b.length; i < length; ++i) {
        map[b[i]] = true;
    }
    for (let i = 0, length = a.length; i < length; ++i) {
        if (a[i] in map) result.push(a[i]);
    }
    return result;
}

function intersect_filter_includes(a, b) {
    return a.filter(el => b.includes(el));
}

function intersect_filter_has_this(a, b) {
    return a.filter(Set.prototype.has, new Set(b));
}

function intersect_filter_has_arrow(a, b) {
    const set = new Set(b);
    return a.filter(el => set.has(el));
}

function intersect_for_has(a, b) {
    const result = [];
    const set = new Set(b);
    for (let i = 0, length = a.length; i < length; ++i) {
        if (set.has(a[i])) result.push(a[i]);
    }
    return result;
}

Tests:

intersect_for(shortArr1, shortArr2)
intersect_for(shortArr1, shortArr2)
intersect_filter_indexOf(shortArr1, shortArr2)
intersect_filter_indexOf(shortArr1, shortArr2)
intersect_filter_in(shortArr1, shortArr2)
intersect_filter_in(shortArr1, shortArr2)
intersect_for_in(shortArr1, shortArr2)
intersect_for_in(shortArr1, shortArr2)
intersect_filter_includes(shortArr1, shortArr2)
intersect_filter_includes(shortArr1, shortArr2)
intersect_filter_has_this(shortArr1, shortArr2)
intersect_filter_has_this(shortArr1, shortArr2)
intersect_filter_has_arrow(shortArr1, shortArr2)
intersect_filter_has_arrow(shortArr1, shortArr2)
intersect_for_has(shortArr1, shortArr2)
intersect_for_has(shortArr1, shortArr2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
intersect_for(shortArr1, shortArr2)
intersect_filter_indexOf(shortArr1, shortArr2)
intersect_filter_in(shortArr1, shortArr2)
intersect_for_in(shortArr1, shortArr2)
intersect_filter_includes(shortArr1, shortArr2)
intersect_filter_has_this(shortArr1, shortArr2)
intersect_filter_has_arrow(shortArr1, shortArr2)
intersect_for_has(shortArr1, shortArr2)

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and options.

**Benchmark Definition:**

The benchmark is designed to measure the performance of different algorithms for finding the intersection of two arrays:

* `intersect_for`
* `intersect_filter_indexOf`
* `intersect_filter_in`
* `intersect_for_in`
* `intersect_filter_includes`
* `intersect_filter_has_this`
* `intersect_filter_has_arrow`
* `intersect_for_has`

The benchmark uses two input arrays, `shortArr1` and `shortArr2`, which are not provided in the specification. The algorithm's performance is measured by executing the test a certain number of times per second (in this case, 985,539, 708,758, 152,818, etc.) for each browser.

**Options:**

The options refer to different implementations or approaches used by each browser:

* `intersect_for`: A simple iterative approach using a loop.
* `intersect_filter_indexOf`: Using the `indexOf()` method to find the index of an element in one array and then using that index to filter the other array.
* `intersect_filter_in`: Using a boolean filter function (`in` operator) to check if an element exists in both arrays.
* `intersect_for_in`: Combining the iterative approach with the `in` operator for better performance.
* `intersect_filter_has_this`: Using the `hasOwnProperty()` method (not applicable for arrays) or `in` operator to check if an element exists in one array.
* `intersect_filter_has_arrow`: Using the `includes()` method (introduced in ECMAScript 2017) to check if an element exists in both arrays.
* `intersect_for_has`: Combining the iterative approach with the `hasOwnProperty()` method or `in` operator for better performance.

**Performance Comparison:**

The benchmark results show that different browsers perform differently depending on the algorithm used. For example, Firefox 78 performs well using `intersect_for_in` and `intersect_filter_has_arrow`, while other browsers may favor different algorithms.

In general, the benchmark highlights the importance of optimizing array intersection operations, as they can be computationally intensive and affect performance in many applications.

Related benchmarks: