Benchmark: Proxy target[key] vs Reflect.get vs get function (fixed)

Script Preparation code:

const obj = {
    a: 'a',
    b: 'b',
    c: 'c'
}

const proxyReflect = new Proxy(obj, {
    get(target, key, receiver) {
        return Reflect.get(target, key, receiver)
    }
})

const proxy = new Proxy(obj, {
    get(target, key, receiver) {
        return target[key]
    }
})

function getAFromProxy() {
    return proxy.a;
}

function getA() {
    return obj.a;
}

function getAFromFunction() {
    return getA()
}

function getAFromProxyReflect() {
    return proxyReflect.a;
}

const outerProxyGetFunction = new Proxy({}, {
    get(target, key, receiver) {
        return getAFromFunction()
    }
})

const outerProxyProxy = new Proxy({}, {
    get() {
        return getAFromProxy()
    }
})

const outerProxyProxyReflect = new Proxy({}, {
    get() {
        return getAFromProxyReflect()
    }
})

function getOuterProxyGetFunction(){
 return outerProxyGetFunction 
}

function getOuterProxyProxyAccess(){
 return outerProxyProxy 
}

function getOuterProxyReflectAccess(){
 return outerProxyProxyReflect 
}

Tests:

get function
getAFromFunction()
proxy target[key]
getAFromProxy()
proxy reflect.get
getAFromProxyReflect()
get function wrapped in proxy
getOuterProxyGetFunction().a
proxy wrapped in proxy
getOuterProxyProxyAccess().a
proxy reflect.get wrapped in proxy
getOuterProxyReflectAccess().a

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
get function
proxy target[key]
proxy reflect.get
get function wrapped in proxy
proxy wrapped in proxy
proxy reflect.get wrapped in proxy

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
get function	6223133.5 Ops/sec
proxy target[key]	8680945.0 Ops/sec
proxy reflect.get	3390830.0 Ops/sec
get function wrapped in proxy	3668758.2 Ops/sec
proxy wrapped in proxy	4294172.5 Ops/sec
proxy reflect.get wrapped in proxy	2418093.8 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll dive right into explaining the benchmark.

**Benchmark Overview**

The provided benchmark measures the performance of different approaches to access property `a` on an object `obj`. The object is created with three properties: `a`, `b`, and `c`.

**Options Compared**

There are four options compared:

1. **`get function`**: This approach uses a regular function `getA()` that returns the value of `obj.a`.
2. **`proxy target[key]`**: This approach uses a Proxy object `proxy` to access property `a`. The Proxy's `get` trap is defined to return the value of `target[key]`, which in this case is just `obj[a]`.
3. **`proxy reflect.get`**: This approach uses a Proxy object `proxyReflect` with a Proxy handler that uses the `Reflect.get()` function to access property `a`. The `get` trap returns the result of `Reflect.get(target, key, receiver)`, which in this case is just `obj[key]`.
4. **`get function wrapped in proxy`**: This approach uses a regular function `getAFromFunction()` that returns the value of `proxy.a`, where `proxy` is the same Proxy object used in option 2.
5. **`proxy wrapped in proxy`**: This approach creates another Proxy object `outerProxy` with a similar Proxy handler to `proxy`. The `get` trap returns the result of accessing property `a` on the inner Proxy object, which in this case is just `proxy.a`.
6. **`proxy reflect.get wrapped in proxy`**: This approach uses a similar Proxy handler as option 3, but on the outer Proxy object.

**Pros and Cons**

Here's a brief summary of the pros and cons for each approach:

1. **`get function`**:
	* Pros: Simple, easy to understand.
	* Cons: May incur additional overhead due to function creation and call.
2. **`proxy target[key]`**:
	* Pros: Efficiently accesses property `a` without creating a new object or function.
	* Cons: May not be as intuitive or readable for some developers.
3. **`proxy reflect.get`**:
	* Pros: Uses the efficient `Reflect.get()` function to access properties.
	* Cons: Requires understanding of Proxy handlers and the `Reflect` API.
4. **`get function wrapped in proxy`**:
	* Pros: Combines the benefits of using a regular function with a Proxy object.
	* Cons: May introduce additional overhead due to function creation and call.
5. **`proxy wrapped in proxy`**:
	* Pros: Creates an isolated scope for accessing property `a`, which can be beneficial in certain scenarios.
	* Cons: May not be as efficient as option 3, and introduces unnecessary complexity.
6. **`proxy reflect.get wrapped in proxy`**:
	* Pros: Combines the efficiency of using `Reflect.get()` with the benefits of a Proxy object.
	* Cons: Requires understanding of Proxy handlers and the `Reflect` API.

**Benchmark Results**

The benchmark results show that options 3 (`proxy reflect.get`) and option 6 (`proxy reflect.get wrapped in proxy`) are generally faster than the other options. However, option 4 (`get function wrapped in proxy`) is still relatively efficient.

Keep in mind that these results may vary depending on your specific use case and JavaScript engine implementation.

I hope this explanation helps!

Related benchmarks:

Proxy target[key] vs Reflect.get vs get function (fixed) (version: 0)

Comparing performance of: get function vs proxy target[key] vs proxy reflect.get vs get function wrapped in proxy vs proxy wrapped in proxy vs proxy reflect.get wrapped in proxy

Created: one year ago by: Registered User

Jump to the latest result

get function

proxy target[key]

proxy reflect.get

get function wrapped in proxy

proxy wrapped in proxy

proxy reflect.get wrapped in proxy

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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