Benchmark: Public vs Private properties

Script Preparation code:

class Test {
	
  	get bar() { return this.#bar };
    set bar(v) { this.#bar = v }; 
  
	foo = 1;
	#bar = 1;
}
var test = new Test;
var x;

Tests:

Direct get
x = test.foo;
proxied get
x = test.bar
direct set
test.foo = 2;
proxied set
test.bar = 2;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Direct get
proxied get
direct set
proxied set

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 12 hours ago):

LLMs can make mistakes. Check important info.

### Benchmark Overview

The benchmark compares the performance of accessing properties in a class using two different approaches: direct access to public properties versus accessing private properties via getters and setters. This is relevant for understanding the impact of encapsulation on performance, a topic of interest for developers looking to maintain clean code while minimizing performance overhead.

### Options Compared

1. **Direct Property Access:**
   - **Test Case:** 
     - `x = test.foo;` (Direct get)
     - `test.foo = 2;` (Direct set)
   - **Description:** This approach accesses and modifies a public property (`foo`) directly.

2. **Getter/Setter Access:**
   - **Test Case:**
     - `x = test.bar;` (Proxied get)
     - `test.bar = 2;` (Proxied set)
   - **Description:** This approach accesses and modifies a private property (`#bar`) through a getter (`bar`) and setter methods. The usage of the hash (`#`) prefix indicates that `#bar` is a private class field, which is only accessible within the class itself.

### Performance Results

The benchmark results provided show execution speeds for each test case, measured in executions per second:

- **Proxied Set:** 18,209,586.0 executions per second
- **Direct Set:** 18,143,504.0 executions per second
- **Proxied Get:** 8,008,743.0 executions per second
- **Direct Get:** 8,003,123.0 executions per second

### Pros/Cons of Each Approach

1. **Direct Property Access (Pros):**
   - **Performance:** Generally faster due to the direct access to memory without the overhead of function calls.
   - **Simplicity:** Easier syntax can lead to clearer code.

**Cons:**
   - **Encapsulation:** Does not allow for validation or transformation logic when setting or getting values, which can lead to unintended side effects.

2. **Getter/Setter Access (Pros):**
   - **Encapsulation:** Allows for controlled access to private properties, which can include validation checks or transformation of data upon retrieval or mutation.
   - **Maintainability:** Facilitates future changes in the implementation while retaining the same interface.

**Cons:**
   - **Performance Overhead:** Function calls introduce additional latency compared to direct property access, making these operations slower.
   - **Complexity:** More lines of code, which can make simple operations less clear.

### Other Considerations

- **Optimization:** The results suggested that even though direct access is often faster (as indicated by the benchmark results), the difference may not be significant enough in real-world applications unless performance is a critical concern.
- **Usage Context:** If reading and writing properties are frequent operations that require high performance, developers might prefer direct access. However, if properties need to be validated or controlled, getters and setters may be more appropriate despite the performance cost.
- **JavaScript Class Features:** This benchmark is leveraging modern JavaScript features such as:
  - **Private Class Fields:** The `#` syntax is used to declare private properties, a significant addition in JavaScript that promotes encapsulation.
  
### Alternatives

1. **Static Methods:**
   - Instead of getters and setters, static methods could be used for encapsulation and logic, but this would mean losing the syntactic sugar of property access.

2. **Proxies:** 
   - JavaScript `Proxy` objects can be used for dynamic behavior related to property access and modification without explicitly defining getters and setters.

3. **Immutable Data Structures:**
   - Using libraries like Immutable.js can provide performance benefits in specific contexts by optimizing how data is stored and accessed, though it shifts the paradigm from mutable to immutable structures.

### Conclusion

In conclusion, this benchmark effectively illustrates the trade-offs between direct property access and encapsulated getter/setter access in JavaScript classes. Developers must weigh the benefits of performance against the principles of clean code and maintainability when choosing which approach to adopt in their applications.

Latest run results:

Run details: (Test run date: 15 hours ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15

Browser/OS: Safari 18 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Direct get	8003123.0 Ops/sec
proxied get	8008743.0 Ops/sec
direct set	18143504.0 Ops/sec
proxied set	18209586.0 Ops/sec

Related benchmarks:

Public vs Private properties (version: 1)

Comparing the get and set performance of directly accessing a field on a class versus using a getter/setter pair on a private property.

Comparing performance of: Direct get vs proxied get vs direct set vs proxied set

Created: 15 hours ago by: Guest

Jump to the latest result

Direct get

proxied get

direct set

proxied set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 12 hours ago):