Benchmark: Access to Proxy vs Object Another one

Script Preparation code:

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

Tests:

Object access
object.value;
Proxy access
proxy.value
Proxy with get handler access
proxyWithHandler.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

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is being tested?**

The provided JSON represents a benchmark that tests the performance difference between accessing an object directly and using a Proxy object to access its properties.

In the "Script Preparation Code", we have:

* An object `object` with a property `value`.
* A Proxy object `proxy` created from `object`, which means it delegates all accesses to `object`. This is done by passing an empty object `{}` as the second argument to the `Proxy` constructor, which specifies the handler for all properties. The `get` method in the handler simply returns the value of the corresponding property on the target object (`target`).
* Another Proxy object `proxyWithHandler` created from `object`, but with a custom `get` handler that returns the value of the corresponding property directly, without delegating to `target`.

The test cases are designed to measure the performance difference between accessing these three scenarios:

1. Direct object access (`object.value;`)
2. Proxy access (`proxy.value;`)
3. Proxy with get handler access (`proxyWithHandler.value;`)

**Options compared**

We have two options being compared:

* **Direct Object Access**: This is the most straightforward way to access an object property.
* **Proxy Access**: Using a Proxy object to access its properties, which can be useful in certain scenarios (e.g., controlling access to sensitive data).

The key differences between these approaches are:

* **Delegation**: In the Proxy case, accesses delegate to the target object. This might introduce additional overhead due to function calls and lookups.
* **Customization**: With a custom `get` handler, you can manipulate the property access in more complex ways.

**Pros and Cons**

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

* **Direct Object Access**
	+ Pros: Simple, straightforward, no overhead.
	+ Cons: May not be suitable for scenarios where control over property access is needed.
* **Proxy Access**
	+ Pros: Can provide fine-grained control over property access, useful in certain scenarios (e.g., data encryption).
	+ Cons: Introduces additional overhead due to delegation and potentially slower lookups.

**Library/Utility**

In this benchmark, the `Proxy` object is used as a utility to create Proxy objects with custom handlers. The `get` method is used to specify how properties are accessed on the proxy object.

**Special JS feature/syntax**

There's no special JavaScript feature or syntax being tested here. The focus is on understanding the performance difference between direct object access and using a Proxy object to access its properties.

**Other alternatives**

If you're looking for alternative approaches, consider:

* **Using a library like ProxyHandler**: This provides a more robust way to create custom proxy handlers.
* **Implementing your own property access mechanism**: If you have specific requirements or use cases, you might need to implement your own property access mechanism (e.g., using a custom object or function).

Keep in mind that the choice of approach depends on the specific use case and requirements.

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 106 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object access	5426859.5 Ops/sec
Proxy access	4304041.5 Ops/sec
Proxy with get handler access	4328838.0 Ops/sec

Related benchmarks:

Access to Proxy vs Object Another one (version: 0)

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

Created: 2 years ago by: Guest

Jump to the latest result

Object access

Proxy access

Proxy with get handler access

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):