Run results for: Is String Set be faster than many equal? (3)

Run details:

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

Browser: Chrome 122

Operating system: Mac OS X 10.15.7

Device Platform: Desktop

Date tested: 2 years ago

Test name	Executions per second
Without Set	214.3 Ops/sec
With Set	13892.4 Ops/sec

HTML Preparation code:

<script>
    var n00 = 9000; // sufficient large no. for init
    var n11 = 400; // no. of rules
    var n12 = 2000; // no. of items

    var s01, s02, f01, f02, st;

    var test01 = function() {
        const rules = s01;
        const items = s02;
        const f = f01;
        let result = 0;
        let ui = 0;
        let vi = 0;
        for (const item of items) {
            ui++;
            if (f(item)) continue;
            vi++;
            result += ui;
        }
        return `${vi}|${result}`;
    }

    var test02 = function() {
        const rules = s01;
        const items = s02;
        const f = f02;
        let result = 0;
        let ui = 0;
        let vi = 0;
        for (const item of items) {
            ui++;
            if (f(item, st)) continue;
            vi++;
            result += ui;
        }
        return `${vi}|${result}`;
    }

    var initialFn = function() {

        const fullList = [...new Set(new Array(n00).fill(0).map((e, i) => `${i}::${crypto.randomUUID()}`))]; // unique random samples
        let trialCount = 8;
        do {
            if (--trialCount < 0) throw new Error(`incorrect lengths`);
            const k01 = new Array(n00).fill(0).map((e, i) => Math.random() > 0.5);
            const k02 = new Array(n00).fill(0).map((e, i) => Math.random() > 0.5);
            const m01 = fullList.map((e, i) => k01[i] ? e : null).filter(e => e).sort((a, b) => Math.random() - 0.5);
            const m02 = fullList.map((e, i) => k02[i] ? e : null).filter(e => e).sort((a, b) => Math.random() - 0.5);
            s01 = m01.slice(0, n11); // 400 rules
            s02 = m02.slice(0, n12); // 2000 items
        } while (s01.length < n11 || s02.length < n12);
        f01 = new Function('key', s01.map(e => `if(key==='${e}')return true;`).join('\n') + 'return false;');
        f02 = new Function('key', 's', `if(s.has(key))return true;` + 'return false;');
        st = new Set(s01);
    }
</script>

Script Preparation code:

Benchmark.prototype.setup = function() {

    initialFn();

    const rr01 = test01();
    const rr02 = test02();
    if (rr01 !== rr02) throw new Error(`test01/02 mismatched - ${rr01} & ${rr02}`);

    console.log('test 01/02', rr01);

};


Benchmark.prototype.teardown = function() {
    s01.length = 0;
    s02.length = 0;
    st.clear();
    s01 = s02 = f01 = f02 = st = null;
}

Tests:

Without Set
test01();
With Set
test02();

Run results for: Is String Set be faster than many equal? (3)

Without Set

With Set