Benchmark: Access property directly vs Getter/Setter

Script Preparation code:

class Foo {
	bar = {
      a: {
        val: 123
      }
    }

	get propAccessor() {
		return this.bar.a.val;
	}

	set propAccessor(val) {
		this.bar.a.val = val;
	}
}

var obj = new Foo();

Tests:

Read directly from prop
var value = obj.bar.a.val;
Set directly to prop
obj.bar.a.val = 123;
Read from getter
var value = obj.propAccessor;
Set to setter
obj.propAccessor = 123;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Read directly from prop
Set directly to prop
Read from getter
Set to setter

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested.

**Benchmark Definition:**

The benchmark is comparing the performance of accessing properties directly versus using getter/setter methods in JavaScript. The script defines a class `Foo` with a nested object `bar` containing a property `a.val`. Two getters and setters are defined for the `propAccessor` property, which has access to `bar.a.val`.

**Test Cases:**

There are four test cases:

1. **Read directly from prop**: Accessing `obj.bar.a.val` without using getter/setter methods.
2. **Set directly to prop**: Assigning a value to `obj.bar.a.val` without using getter/setter methods.
3. **Read from getter**: Using the `propAccessor` getter method to access `bar.a.val`.
4. **Set to setter**: Using the `propAccessor` setter method to assign a value to `bar.a.val`.

**Library and Purpose:**

The `prop_accessor.js` library is used in the benchmark definition. This library provides a simple implementation of getters and setters for properties.

**Special JS Feature/Syntax:**

There are no special JavaScript features or syntaxes being tested in this benchmark, except for the use of getters and setters which are a standard part of the language.

**Pros and Cons:**

Using getter/setter methods can provide benefits such as:

* **Encapsulation**: Hiding internal implementation details and exposing only necessary information through public interfaces.
* **Flexibility**: Allowing for more complex logic in the getter/setter methods if needed.
* **Validation**: Enabling validation of input values before assignment.

However, using getters and setters can also incur performance overhead compared to direct property access. The trade-off depends on the specific use case and requirements.

**Other Alternatives:**

If you're looking for alternative approaches to this benchmark, consider:

1. **Direct Property Access with Cache**: Implementing a cache to store frequently accessed values to mitigate the performance impact of getter/setter methods.
2. **Proxies**: Using JavaScript's built-in `Proxy` objects to create dynamic getters and setters that can be optimized for specific use cases.
3. **Memoization**: Applying memoization techniques to optimize the execution of getter/setter methods by caching previously computed values.

Keep in mind that these alternatives may introduce additional complexity or overhead, which should be carefully considered based on your specific requirements.

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

Browser/OS: Chrome 108 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Read directly from prop	27726224.0 Ops/sec
Set directly to prop	27070570.0 Ops/sec
Read from getter	27754454.0 Ops/sec
Set to setter	27174544.0 Ops/sec

Related benchmarks:

Access property directly vs Getter/Setter (version: 0)

Comparing performance of: Read directly from prop vs Set directly to prop vs Read from getter vs Set to setter

Created: one year ago by: Registered User

Jump to the latest result

Read directly from prop

Set directly to prop

Read from getter

Set to setter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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