Benchmark: Direct access to property vs Getter/Setter

Script Preparation code:

class MyObj {
	prop = undefined

	get propAccessor() {
		return this.prop;
	}

	set propAccessor(val) {
		this.prop = val;
	}
}

var obj = new MyObj();

Tests:

Read directly from prop
var value = obj.prop;
Set directly to prop
obj.prop = 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

Latest run results:

Run details: (Test run date: 3 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0

Browser/OS: Firefox 134 on Windows

View result in a separate tab

Test name	Executions per second
Read directly from prop	1476743424.0 Ops/sec
Set directly to prop	998636096.0 Ops/sec
Read from getter	1430136448.0 Ops/sec
Set to setter	984640768.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the provided benchmark.

**Benchmark Definition JSON**

The provided JSON defines a JavaScript benchmark with two main components:

1. **Script Preparation Code**: This is a JavaScript class `MyObj` that has a property `prop` initialized to `undefined`. The class also defines getter and setter methods for the `prop` property, named `propAccessor`.
2. **Html Preparation Code**: There is no HTML code provided in this benchmark.

The purpose of this benchmark is to compare the performance of direct access to properties versus using getters and setters in JavaScript.

**Test Cases**

There are four test cases:

1. **Read directly from prop**: This test case measures the execution time of accessing the `prop` property directly on the object.
2. **Set directly to prop**: This test case measures the execution time of setting the value of the `prop` property directly on the object.
3. **Read from getter**: This test case measures the execution time of accessing the `propAccessor` getter method on the object.
4. **Set to setter**: This test case measures the execution time of setting the value of the `propAccessor` setter method on the object.

**Options Compared**

In this benchmark, two options are compared:

* Direct access to properties (methods 1 and 2)
* Using getters and setters (method 3 and 4)

**Pros and Cons of Different Approaches**

**Direct Access**

* Pros:
	+ Faster execution time since there is no overhead from calling a method.
	+ Less memory allocation since the property is accessed directly.
* Cons:
	+ May lead to accidental modifications or overwriting of values if not properly protected.
	+ Limited control over data validation and transformation.

**Getters and Setters**

* Pros:
	+ Provides a layer of abstraction and protection against accidental modifications or overwriting of values.
	+ Allows for more control over data validation and transformation before it is accessed.
	+ Can be used to implement additional logic, such as logging or caching.
* Cons:
	+ May introduce overhead due to the method call.
	+ Requires more memory allocation since a new object is created when accessing the property through the getter or setter.

**Libraries Used**

There is no explicit library mentioned in the benchmark definition JSON. However, it is assumed that the `MyObj` class and its properties/ methods are part of the JavaScript standard library or a custom implementation.

**Special JS Features/Syntax**

There are no special JavaScript features or syntax used in this benchmark beyond what is considered standard for JavaScript.

**Other Alternatives**

Other alternatives to direct access and getters/setters include:

* **Computed Properties**: Similar to getters and setters, but can be used directly on objects without the need for a separate getter function.
* **Property Accessors**: A more functional approach to property access, where each property is an accessor function that returns or sets its value.

These alternatives offer different trade-offs between performance, security, and code readability.

Related benchmarks:

Direct access to property 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: 2 years 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 6 months ago):