Benchmark: Calling method of a proxy vs object

Script Preparation code:

class TestClass {
    constructor() {}

    getNumber() {
        return 1;
    }
}

object = new TestClass();
proxy = new Proxy(new TestClass(), []);
proxyWithHandler = new Proxy(new TestClass(), {
    set(target, prop, value) {
        return Reflect.set(target, prop, value)
    }
});

Tests:

Object method call
object.getNumber();
Proxy method call
proxy.getNumber();
Proxy with handler method call
proxyWithHandler.getNumber();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object method call
Proxy method call
Proxy with handler method call

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/107.0.0.0 Safari/537.36

Browser/OS: Chrome 107 on Linux

View result in a separate tab

Test name	Executions per second
Object method call	8947316.0 Ops/sec
Proxy method call	5904953.5 Ops/sec
Proxy with handler method call	6008735.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its test cases.

**Benchmark Overview**

The benchmark compares the performance of three different ways to call a method on an object:

1. Directly calling the `getNumber` method on the `object`.
2. Calling the `getNumber` method through a proxy (without any handlers).
3. Calling the `getNumber` method through a proxy with a handler.

**Proxy and Handler**

In JavaScript, a proxy is an object that acts as an intermediary between another object and a target object. Proxies allow you to customize behavior, such as changing property access or mutation, without modifying the original object.

The handler in this benchmark is a function that is used to resolve method calls on the proxy. In this case, the handler simply delegates the call to `Reflect.set`, which sets a property on the target object. This effectively allows us to observe how the underlying method is called when using a proxy with a handler.

**Test Cases**

The three test cases are:

1. **Object Method Call**: Calls the `getNumber` method directly on the `object`.
2. **Proxy Method Call**: Calls the `getNumber` method through the proxy (without any handlers).
3. **Proxy with Handler Method Call**: Calls the `getNumber` method through the proxy with a handler.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Object Method Call**:
	* Pros: Simple, direct call to the underlying method.
	* Cons: No customization or control over the call behavior.
2. **Proxy Method Call** (without handler):
	* Pros: Allows for some level of control over the call behavior through proxy configuration.
	* Cons: The actual method being called is not observable, as it's handled by the proxy.
3. **Proxy with Handler Method Call**:
	* Pros: Provides a way to observe and customize the underlying method being called.
	* Cons: Introduces additional complexity due to the need for a handler function.

**Library Usage**

In this benchmark, no specific libraries are used beyond the built-in `Proxy` API in JavaScript. However, the use of `Reflect.set` as a handler function implies knowledge of the Reflect API, which is a part of the ECMAScript standard.

**Special JS Features and Syntax**

This benchmark does not explicitly use any special JavaScript features or syntax beyond the use of proxies and the Reflect API. If you're interested in exploring other aspects of JavaScript performance, there are many other benchmarks available on MeasureThat.net that cover different topics, such as array manipulation, closure behavior, or more advanced concurrency scenarios.

**Alternative Approaches**

If you'd like to explore alternative approaches for calling methods on objects, here are a few options:

1. **Using a wrapper function**: You could create a separate function that wraps the original method call and provides additional functionality, such as logging or validation.
2. **Implementing a macro system**: You could use a macro system, like a template engine, to generate code for calling methods on objects with customized behavior.
3. **Using a third-party library**: Depending on your specific requirements, you might consider using a library that provides a more robust and customizable way of handling method calls on objects.

I hope this explanation helps! Let me know if you have any further questions or need clarification on any aspect of the benchmark.

Related benchmarks:

Calling method of a proxy vs object (version: 0)

Object method call vs proxy method call vs proxy with a handler method call

Comparing performance of: Object method call vs Proxy method call vs Proxy with handler method call

Created: one year ago by: Guest

Jump to the latest result

Object method call

Proxy method call

Proxy with handler method call

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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