Benchmark: Access to Proxy vs Object vs eval

Script Preparation code:

object = { value: 'data' };
proxy = new Proxy(object, {})
proxyWithHandler = new Proxy(object, {
	get(target, prop, receiver) {
    	return Reflect.get(target, prop, receiver)
    }
})

Tests:

Object access
object.value;
Proxy access
proxy.value
Proxy with get handler access
proxyWithHandler.value
eval
eval(`object['value']`)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object access
Proxy access
Proxy with get handler access
eval

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36

Browser/OS: Chrome 116 on Linux

View result in a separate tab

Test name	Executions per second
Object access	10169474.0 Ops/sec
Proxy access	7637102.0 Ops/sec
Proxy with get handler access	3749521.8 Ops/sec
eval	2873126.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of accessing an object, its proxy, and `eval()` in JavaScript.

**Benchmark Object**

The provided JSON benchmark represents three different ways to access the value of an object:

1. **Direct Object Access**: The simplest way to access the value is using the dot notation on the original object (`object.value`).
2. **Proxy Access**: A proxy object can be created, which delegates property access to another target object. In this case, `proxy.value` will call the `get()` handler on the proxy object.
3. **Proxy with Get Handler Access**: A custom get handler is defined for the proxy object, which simply calls `Reflect.get()` on the original object.

**Options Compared**

The benchmark compares the performance of these three approaches:

*   Direct Object Access
*   Proxy Access (with a default handler)
*   Proxy with Custom Get Handler Access

**Pros and Cons**

Here's a brief overview of each approach:

### 1. Direct Object Access (`object.value`)

Pros:

*   Fastest, as it directly accesses the property on the original object.

Cons:

*   May trigger additional checks or computations if the property is not present or has specific access control.
*   Does not provide any error handling for invalid or missing properties.

### 2. Proxy Access (`proxy.value`)

Pros:

*   Can be useful when you want to intercept property access and perform custom actions before resolving the value.
*   Provides some protection against null pointer exceptions, as attempting to access a non-existent property will raise an error.

Cons:

*   May incur additional overhead due to the creation and maintenance of the proxy object.
*   Does not provide explicit control over property access or resolution.

### 3. Proxy with Custom Get Handler Access (`proxyWithHandler.value`)

Pros:

*   Provides full control over property access, allowing you to customize how properties are resolved.
*   Useful when you need more complex logic for handling property access, such as caching or transforming values.

Cons:

*   More complex and potentially slower due to the added overhead of defining a custom get handler.
*   Requires careful consideration of potential edge cases and performance implications.

**Libraries and Features**

None of these options rely on any external libraries. However, `Reflect.get()` is used in the Proxy with Custom Get Handler Access approach, which is a JavaScript standard library feature introduced in ECMAScript 2015 (ES6).

**Special JS Features or Syntax**

The test case uses the `new` keyword to create objects and the `Proxy` constructor to define proxy objects. The `Reflect.get()` function is used within the custom get handler defined for the proxy object.

**Alternatives**

If you need more complex logic for handling property access, consider using other approaches like:

*   Using a caching mechanism (e.g., LRU cache) or memoization techniques.
*   Implementing your own property accessor functions with explicit control over resolution and computation.
*   Leveraging third-party libraries or frameworks that provide optimized property access mechanisms.

Keep in mind that the best approach depends on the specific requirements of your use case.

Related benchmarks:

Access to Proxy vs Object vs eval (version: 0)

Comparing performance of: Object access vs Proxy access vs Proxy with get handler access vs eval

Created: one year ago by: Guest

Jump to the latest result

Object access

Proxy access

Proxy with get handler access

eval

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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