Benchmark: ES6 property (get/set) & getter/setter function vs direct access to object attribute (private and not)

ES6 property (get/set) & getter/setter function vs direct access to object attribute (private and not) (version: 0)

Comparing performance of: Public ES6 property (get) vs Public Getter function vs Public Directly get vs Public ES6 property (set) vs Public Setter function vs Public Directly set vs Private ES6 property (get) vs Private Getter function vs Private ES6 property (set) vs Private Setter function

Created: one year ago by: Guest

Jump to the latest result

Script Preparation code:

class Private {
    #value = 0;
    constructor() {
        this.#value = 1
    }
    get value() {
        return this.#value
    }
    set value(x) {
        this.#value = x
    }
    getValue() {
        return this.#value
    }
    setValue(x) {
        this.#value = x
    }
}
class Public {
    value = 0;
    constructor() {
        this.value = 1
    }
    get value() {
        return this.value
    }
    set value(x) {
        this.value = x
    }
    getValue() {
        return this.value
    }
    setValue(x) {
        this.value = x
    }
}
var private = new Private();
var public = new Public();
var val = 0;

AخA
 
class Private {    #value = 0;    constructor() {        this.#value = 1    }    get value() {        return this.#value    }    set value(x) {        this.#value = x    }    getValue() {        return this.#value    }    setValue(x) {        this.#value = x    }}class Public {    value = 0;    constructor() {        this.value = 1    }    get value() {        return this.value    }    set value(x) {        this.value = x    }    getValue() {        return this.value    }    setValue(x) {        this.value = x    }}var private = new Private();var public = new Public();var val = 0;

Tests:

Public ES6 property (get)
val = public.value;
val = public.value;
Public Getter function
val = public.getValue();
val = public.getValue();
Public Directly get
val = public.value;
val = public.value;
Public ES6 property (set)
public.value = 1;
public.value = 1;
Public Setter function
public.setValue(1);
public.setValue(1);
Public Directly set
public.value = 1;
public.value = 1;
Private ES6 property (get)
val = private.value;
val = private.value;
Private Getter function
val = private.getValue();
val = private.getValue();
Private ES6 property (set)
private.value = 1;
private.value = 1;
Private Setter function
private.setValue(1);
private.setValue(1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Public ES6 property (get)
Public Getter function
Public Directly get
Public ES6 property (set)
Public Setter function
Public Directly set
Private ES6 property (get)
Private Getter function
Private ES6 property (set)
Private Setter function

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Android 13; Mobile; rv:125.0) Gecko/125.0 Firefox/125.0

Browser/OS: Firefox Mobile 125 on Android

View result in a separate tab

Test name	Executions per second
Public ES6 property (get)	299593344.0 Ops/sec
Public Getter function	282615040.0 Ops/sec
Public Directly get	282472256.0 Ops/sec
Public ES6 property (set)	430841952.0 Ops/sec
Public Setter function	418993696.0 Ops/sec
Public Directly set	425608800.0 Ops/sec
Private ES6 property (get)	286338688.0 Ops/sec
Private Getter function	287016160.0 Ops/sec
Private ES6 property (set)	376575200.0 Ops/sec
Private Setter function	385027200.0 Ops/sec

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

Let's dive into the benchmark and explain what is being tested, compared, and their pros and cons.

Benchmark Definition:

The benchmark measures the performance difference between accessing object attributes directly (using dot notation) versus using ES6 property access with getters and setters. The test cases compare these approaches for both public and private properties of an object.

Test Cases:

There are 8 test cases in total, each comparing a different approach:

Public ES6 property (get)
Public Getter function
Public Directly get
Public ES6 property (set)
Public Setter function
Private ES6 property (set)
Private Setter function
Private ES6 property (get)
Private Getter function

Approaches Compared:

The benchmark compares two approaches:

Direct Access: Accessing object attributes using dot notation (e.g., obj.prop).
ES6 Property Access with Getters and Setters: Using the . operator to access properties, which invokes a getter or setter function depending on the context.

Pros and Cons of Each Approach:

Direct Access:
- Pros:
  - Faster performance since it avoids the overhead of function calls.
  - Easier to read and write code.
- Cons:
  - Can lead to bugs if not used carefully (e.g., accessing private properties directly).
ES6 Property Access with Getters and Setters:
- Pros:
  - Provides a way to encapsulate data and behavior, making it easier to reason about code.
  - Allows for more flexible access control (e.g., read-only vs. read-write properties).
- Cons:
  - Slower performance due to the overhead of function calls.
  - Can lead to confusion if not used carefully.

Libraries Used:

The benchmark uses JavaScript, which is a dynamic language that allows for easy creation of getters and setters using functions. The Object.defineProperty() method is used to define getter and setter properties on objects.

Device and Browser:

The benchmark results are reported for Firefox Mobile 125 on an Android device. This means the results may not be representative of other devices or browsers.

Now, let's take a deep breath and move on to analyzing the results...

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explain what is being tested, compared, and their pros and cons.

**Benchmark Definition:**

**Test Cases:**

There are 8 test cases in total, each comparing a different approach:

1. Public ES6 property (get)
2. Public Getter function
3. Public Directly get
4. Public ES6 property (set)
5. Public Setter function
6. Private ES6 property (set)
7. Private Setter function
8. Private ES6 property (get)
9. Private Getter function

**Approaches Compared:**

The benchmark compares two approaches:

1. **Direct Access**: Accessing object attributes using dot notation (e.g., `obj.prop`).
2. **ES6 Property Access with Getters and Setters**: Using the `.` operator to access properties, which invokes a getter or setter function depending on the context.

**Pros and Cons of Each Approach:**

1. **Direct Access**:
	* Pros:
		+ Faster performance since it avoids the overhead of function calls.
		+ Easier to read and write code.
	* Cons:
		+ Can lead to bugs if not used carefully (e.g., accessing private properties directly).
2. **ES6 Property Access with Getters and Setters**:
	* Pros:
		+ Provides a way to encapsulate data and behavior, making it easier to reason about code.
		+ Allows for more flexible access control (e.g., read-only vs. read-write properties).
	* Cons:
		+ Slower performance due to the overhead of function calls.
		+ Can lead to confusion if not used carefully.

**Libraries Used:**

The benchmark uses JavaScript, which is a dynamic language that allows for easy creation of getters and setters using functions. The `Object.defineProperty()` method is used to define getter and setter properties on objects.

**Device and Browser:**

The benchmark results are reported for Firefox Mobile 125 on an Android device. This means the results may not be representative of other devices or browsers.

Now, let's take a deep breath and move on to analyzing the results...

Related benchmarks: