Benchmark: Frozen object access vs ordinary object access

Script Preparation code:

const obj = {a: 1, b: 2, c: 3, d: 4};
const sealedObj = Object.freeze({a: 1, b: 2, c: 3, d: 4, __proto__: null});

let v = null;

Tests:

Frozen object access
v = sealedObj.a; v = sealedObj.b; v = sealedObj.c; v = sealedObj.d;
Ordinary object access
v = obj.a; v = obj.b; v = obj.c; v = obj.d;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Frozen object access
Ordinary object access

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36

Browser/OS: Chrome 135 on Linux

View result in a separate tab

Test name	Executions per second
Frozen object access	3080224.8 Ops/sec
Ordinary object access	3347081.2 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 15 days ago):

LLMs can make mistakes. Check important info.

The benchmark test conducted compares the performance of accessing properties in JavaScript between a regular (ordinary) object and a frozen object. Here’s a breakdown of the benchmark, its key elements, and underlying concepts:

### Benchmark Overview

1. **Frozen Object Access:** This test measures how quickly properties can be accessed in an object that has been frozen using `Object.freeze()`.
   
2. **Ordinary Object Access:** This test measures the same property accesses but uses a regular JavaScript object that is not frozen.

### Options Being Compared

- **Frozen Object (`sealedObj`)**:
  - Created using `Object.freeze()`, which makes the object immutable. This means that once defined, properties cannot be added, removed, or modified. It also prevents changes to the prototype.

- **Ordinary Object (`obj`)**:
  - A typical JavaScript object that can be freely modified. Properties can be added, removed, or changed at any time.

### Pros and Cons

#### Frozen Objects (`sealedObj`)
**Pros:**
- **Performance:** Accessing properties of a frozen object can be more performant in certain situations as JavaScript engines may optimize for immutability.
- **Safety:** Preventing changes to the object can reduce side effects and bugs in larger codebases, making code more predictable.

**Cons:**
- **Immutability:** Once frozen, the object cannot be altered. This reduces flexibility if you need to modify the object later.
- **Initial Overhead:** The process of freezing an object has an initial performance cost, though this typically pays off in the long term with more predictable behavior.

#### Ordinary Objects (`obj`)
**Pros:**
- **Flexibility:** Can be modified at any point, allowing for dynamic changes during execution.
- **Simplicity:** There’s no overhead in setting up or managing immutability.

**Cons:**
- **Potential Performance Issues:** If an object is heavily modified, performance can suffer due to potential de-optimizations in the JavaScript engine.
- **Risk of Side Effects:** Other parts of the code can inadvertently change the object, leading to bugs that could be hard to trace.

### Libraries and Features
The benchmark does not incorporate any external libraries; it relies on built-in JavaScript features such as `Object.freeze()`, which is part of JavaScript's Object API. This method is designed specifically for making objects immutable, and it helps developers enforce state management within their applications.

### Other Considerations

- **Real-World Usage:** The benefits of frozen objects are most apparent in applications where data integrity is crucial, such as Flux/Redux state management patterns or in functional programming.
  
- **Alternatives:** Other alternatives for accessing properties in JavaScript include:
  - **Proxy Objects:** For situations where controlled access and mutation of state is needed, using JavaScript's Proxy can be a robust alternative.
  - **Immutable.js or similar Libraries:** For managing immutable data structures in a more comprehensive way, libraries like Immutable.js allow developers to work with a broader variety of data types while ensuring immutability.

### Benchmark Results

According to the latest results:
- **Average executions per second for Ordinary Object Access:** 3,347,081.25
- **Average executions per second for Frozen Object Access:** 3,080,224.75

This shows that accessing properties from ordinary objects is faster than from frozen objects in this specific benchmark scenario, though the difference in performance generally varies based on the specific conditions and JavaScript engine optimizations present.

Related benchmarks:

Frozen object access vs ordinary object access (version: 1)

Comparing performance of: Frozen object access vs Ordinary object access

Created: 15 days ago by: Guest

Jump to the latest result

Frozen object access

Ordinary object access

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 15 days ago):