Run results for: Proxy size - factory

Run details:

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 15_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.5 Mobile/15E148 Safari/604.1

Browser: Mobile Safari 15

Operating system: iOS 15.5

Device Platform: Mobile

Date tested: 2 years ago

Test name	Executions per second
Large Proxy - literal	1021789.9 Ops/sec
Small Proxy - literal	1041386.3 Ops/sec
Large Proxy - class	926489.6 Ops/sec
Small Proxy - class	971011.4 Ops/sec
Large GetterSetter - literal	184361.8 Ops/sec
Small GetterSetter - literal	656997.0 Ops/sec
Large GetterSetter - class	306859.8 Ops/sec
Small GetterSetter - class	728974.1 Ops/sec
control case	1204452.4 Ops/sec
Large Proxy - factory	928362.8 Ops/sec
Small Proxy - factory	972400.0 Ops/sec

Script Preparation code:

function prep() {
    class BigFoo {
        constructor() {
            this.b = 2;
            this.c = 2;
            this.d = 2;
            this.e = 2;
            this.f = 2;
            this.g = 2;
            this.h = 2;
        }
        j() {}
        k() {}
        l() {}
        m() {}
        n() {}
        o() {}
        p() {}
    }

    class LilFoo {
        constructor() {
            this.a = 1;
        }
        i() {}
    }

    function bigBar() {
        return {
            b: 2,
            c: 2,
            d: 2,
            e: 2,
            f: 2,
            g: 2,
            h: 2,
            j: () => {},
            k: () => {},
            l: () => {},
            m: () => {},
            n: () => {},
            o: () => {},
            p: () => {},
        };
    }

    function lilBar() {
        return {
            a: 1,
            i: () => {},
        };
    }

    const handlersP = {
        get: (target, key) => target[key],
        set: (target, key, val) => {
            target[key] = val;
        },
    };

    const handlersD = {
        get() {
            return bValue;
        },
        set(newValue) {
            bValue = newValue;
        },
    };
    return {
        BigFoo,
        LilFoo,
        handlersP,
        handlersD,
        bigBar,
        lilBar
    }
}


function _proxy(target, handlers) {
    for (const key in target) {
        Object.defineProperty(target, key, handlers);
    }
}

Tests:

Large Proxy - literal
const {BigFoo, LilFoo, bigBar, lilBar, handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const proxy = new Proxy(bigFoo, handlersP);
Small Proxy - literal
const {BigFoo, LilFoo, bigBar, lilBar,handlersP, handlersD} = prep(); const _foo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const lilFoo = { a: 1, i: () => {}, }; const proxy = new Proxy(lilFoo, handlersP)
Large Proxy - class
const {BigFoo, LilFoo, bigBar, lilBar,handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = new BigFoo(); const proxy = new Proxy(bigFoo, handlersP)
Small Proxy - class
const {BigFoo, LilFoo, bigBar, lilBar,handlersP, handlersD} = prep(); const _foo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const lilFoo = new LilFoo(); const proxy = new Proxy(lilFoo, handlersP)
Large GetterSetter - literal
const {BigFoo, LilFoo,bigBar, lilBar, handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const proxy = _proxy(bigFoo, handlersD);
Small GetterSetter - literal
const {BigFoo, LilFoo,bigBar, lilBar, handlersP, handlersD} = prep(); const _foo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const lilFoo = { a: 1, i: () => {}, }; const proxy = _proxy(lilFoo, handlersD);
Large GetterSetter - class
const {BigFoo, LilFoo, bigBar, lilBar,handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = new BigFoo(); const proxy = _proxy(bigFoo, handlersD);
Small GetterSetter - class
const {BigFoo, LilFoo,bigBar, lilBar, handlersP, handlersD} = prep(); const _foo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const lilFoo = new LilFoo(); const proxy = _proxy(lilFoo, handlersD);
control case
const {BigFoo, LilFoo, bigBar, lilBar,handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const proxy = bigFoo;
Large Proxy - factory
const {BigFoo, LilFoo, bigBar, lilBar,handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = bigBar(); const proxy = new Proxy(bigFoo, handlersP);
Small Proxy - factory
const {BigFoo, LilFoo, bigBar, lilBar,handlersP, handlersD} = prep(); const _foo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const lilFoo = lilBar(); const proxy = new Proxy(lilFoo, handlersP)

Run results for: Proxy size - factory

Large Proxy - literal

Small Proxy - literal

Large Proxy - class

Small Proxy - class

Large GetterSetter - literal

Small GetterSetter - literal

Large GetterSetter - class

Small GetterSetter - class

control case

Large Proxy - factory

Small Proxy - factory