Benchmark: Data Properties vs. Accessor Properties vs. Getter / Setter Methods 1

Data Properties vs. Accessor Properties vs. Getter / Setter Methods 1 (version: 0)

The purpose of this benchmark is to determine the performance differences between data properties, accessor properties and getters / setter functions.

Comparing performance of: `Read from data property vs Write to data property vs Read from accessor method vs Write to mutator method vs Read from object literal property vs Write to object literal property vs Read from object literal property on prototype vs Write to object literal property on prototype vs Write to object vs Read to object`

Created: 5 years ago by: Guest

Go to the latest result

Script Preparation code:

var data = {
  property: property
};

var property = undefined;

var method = {
  getProperty: function() {
    return property;
  },

  setProperty: function(value) {
    property = value;
  }
};

var objectLiteralAccessor = {
  get property() {
    return property;
  },
  set property(value) {
    property = value;
  }
};

function Class() {
}

Class.prototype = {
  getProperty() {
    return property;
  },
  setProperty(value) {
    property = value;
  },
  get property() {
    return property;
  },
  set property(value) {
    property = value;
  }
};
    
var prototypeAccessor = new Class();

Tests:

Read from data property
var value = data.property;
Write to data property
data.property = true;
Read from accessor method
var value = method.getProperty();
Write to mutator method
method.setProperty(true);
Read from object literal property
var value = objectLiteralAccessor.property;
Write to object literal property
objectLiteralAccessor.property = true;
Read from object literal property on prototype
var value = prototypeAccessor.property;
Write to object literal property on prototype
prototypeAccessor.property = true;
Write to object
var value = prototypeAccessor.getProperty();
Read to object
prototypeAccessor.setProperty(true);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Read from data property
Write to data property
Read from accessor method
Write to mutator method
Read from object literal property
Write to object literal property
Read from object literal property on prototype
Write to object literal property on prototype
Write to object
Read to object

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Android 14; Mobile; rv:137.0) Gecko/137.0 Firefox/137.0

Browser/OS: Firefox Mobile 137 on Android

View result in a separate tab

Read from data property

1053.6M/s

Read to object

669.2M/s

Write to object literal property

668.3M/s

Write to data property

667.2M/s

Write to mutator method

663.2M/s

Write to object literal property on prototype

656.3M/s

Read from object literal property

206.9M/s

Read from object literal property on prototype

205.8M/s

Write to object

205.5M/s

Read from accessor method

200.6M/s

View exact numbers

Test name	Executions per second
✓ Read from data property	1,053,559,040 Ops/sec
Read to object	669,246,784 Ops/sec
Write to object literal property	668,268,608 Ops/sec
Write to data property	667,213,888 Ops/sec
Write to mutator method	663,203,136 Ops/sec
Write to object literal property on prototype	656,327,104 Ops/sec
Read from object literal property	206,934,000 Ops/sec
Read from object literal property on prototype	205,789,296 Ops/sec
Write to object	205,450,240 Ops/sec
Read from accessor method	200,637,168 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested in this benchmark and the different approaches used.

**Benchmark Purpose:**
The purpose of this benchmark is to compare the performance differences between three approaches to access and modify data properties:

1. **Data Properties**: Directly accessing a property on an object using dot notation (e.g., `data.property`).
2. **Accessor Properties**: Using accessor properties with a getter function that returns the value (e.g., `objectLiteralAccessor.property`) or setter functions to modify the value (e.g., `objectLiteralAccessor.property = true;`).
3. **Getter/Setter Methods**: Creating custom methods on an object to access and modify data using function calls (e.g., `method.getProperty()`).

**Approach Comparison:**

* **Data Properties vs. Accessor Properties**: Both approaches are similar in that they use dot notation to access the property, but accessor properties provide a way to encapsulate the getter and setter logic, which can lead to better performance and security.
* **Accessor Properties vs. Getter/Setter Methods**: Accessor properties are more efficient because they avoid the overhead of function calls. However, getter/setter methods provide more flexibility in terms of logic complexity and error handling.

**Performance Results:**
The benchmark results show that accessor properties outperform data properties due to their ability to cache the property value. This caching reduces the number of times the property is looked up, leading to faster execution. Getter/setter methods are slower than accessor properties because they involve function calls, which add overhead.

**Key Insights:**

* Accessor properties can be a more efficient and secure way to access data in objects.
* Getter/setter methods provide flexibility but come with performance overhead due to function calls.
* Caching property values using accessor properties can significantly improve performance.

Overall, this benchmark highlights the importance of choosing an appropriate approach for accessing and modifying data in objects based on performance and security requirements.