Benchmark: Looping frozen object vs non-frozen object

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

const birdSpecies = {
  forest: {
    species: [
      {
        name: "Northern Cardinal",
        physicalCharacteristics: {
          color: "Red",
          size: "Medium",
          beakType: "Conical"
        },
        diet: {
          primary: "Seeds",
          secondary: "Fruits"
        },
        habitat: "Woodlands and forests"
      },
      {
        name: "Woodpecker",
        physicalCharacteristics: {
          color: "Black, White, and Red",
          size: "Medium",
          beakType: "Chisel-shaped"
        },
        diet: {
          primary: "Insects",
          secondary: "Tree sap"
        },
        habitat: "Wooded areas"
      }
    ]
  },
  desert: {
    species: [
      {
        name: "Roadrunner",
        physicalCharacteristics: {
          color: "Brown and White",
          size: "Medium",
          beakType: "Long and Slim"
        },
        diet: {
          primary: "Insects",
          secondary: "Small reptiles"
        },
        habitat: "Desert and arid regions"
      },
      {
        name: "Cactus Wren",
        physicalCharacteristics: {
          color: "Brown with streaks",
          size: "Small",
          beakType: "Curved"
        },
        diet: {
          primary: "Insects",
          secondary: "Seeds"
        },
        habitat: "Cacti and desert shrubs"
      }
    ]
  },
  wetlands: {
    species: [
      {
        name: "Great Blue Heron",
        physicalCharacteristics: {
          color: "Blue-gray",
          size: "Large",
          beakType: "Long and Sharp"
        },
        diet: {
          primary: "Fish",
          secondary: "Amphibians"
        },
        habitat: "Wetlands and marshes"
      },
      {
        name: "American Coot",
        physicalCharacteristics: {
          color: "Dark gray with white bill",
          size: "Medium",
          beakType: "Flat and short"
        },
        diet: {
          primary: "Aquatic plants",
          secondary: "Small invertebrates"
        },
        habitat: "Lakes and wetlands"
      }
    ]
  }
}

const frozenObject = Object.freeze(birdSpecies)
const nonFrozenObject = birdSpecies

Tests:

Loop frozen object
function doStuff(value) { // } for (const habitat in frozenObject) { const data = frozenObject[habitat]; for (const bird of data.species) { for (const key in bird.physicalCharacteristics) { const value = bird.physicalCharacteristics[key]; doStuff(value); } for (const key in bird.diet) { const value = bird.diet[key]; doStuff(value); } } }
Loop non-frozen object
function doStuff(value) { // } for (const habitat in nonFrozenObject) { const data = frozenObject[habitat]; for (const bird of data.species) { for (const key in bird.physicalCharacteristics) { const value = bird.physicalCharacteristics[key]; doStuff(value); } for (const key in bird.diet) { const value = bird.diet[key]; doStuff(value); } } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Loop frozen object
Loop non-frozen object

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:134.0) Gecko/20100101 Firefox/134.0

Browser/OS: Firefox 134 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Loop frozen object	5165897.5 Ops/sec
Loop non-frozen object	5155683.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark presented compares the performance of looping through properties of a **frozen object** versus a **non-frozen object** in JavaScript.

### Explanation of the Benchmark

1. **Benchmark Definition**:
   - The benchmark contains two main test cases:
     - **Looping a Frozen Object**: This test case iterates through the properties of `frozenObject`, which is created by applying `Object.freeze()` to the `birdSpecies` object. This means that `frozenObject` is immutable, and its properties cannot be added, removed, or modified after its initial creation.
     - **Looping a Non-Frozen Object**: This test case loops through the properties of `nonFrozenObject`, which references the same `birdSpecies` object without any structural restrictions imposed by `Object.freeze()`.

2. **Libraries or Features Used**:
   - The `Object.freeze()` method is pivotal to this benchmark. This JavaScript function is used to freeze an object, rendering it immutable. Any attempts to modify a frozen object (including adding or removing properties) will result in a runtime error in strict mode or fail silently in non-strict mode.
   
### Pros and Cons

#### Frozen Object
- **Pros**:
  - **Safety**: Prevents accidental modifications to object properties, which can help maintain the integrity of data, especially in large applications.
  - **Potential Performance Boost**: In some engines, frozen objects can provide performance improvements for property access due to optimizations for immutable structures.
  
- **Cons**:
  - **Immutability**: Once frozen, you cannot change the object's properties, which may not be suitable in cases where object manipulation is necessary.
  - **Increased Complexity**: Developers must manage the lifecycle of mutable and immutable objects, potentially using alternate structures for configurations or when updates are needed.

#### Non-Frozen Object
- **Pros**:
  - **Flexibility**: Properties can be added, modified, or deleted at any point, offering significant flexibility in data handling.
  - **Dynamic Behavior**: Ideal for scenarios where the object’s structure may change dynamically during the application runtime.

- **Cons**:
  - **Risk of Modification**: Increased risk of accidental changes to the object properties, which could lead to bugs in the software.
  - **Performance**: In some cases, looping through non-frozen objects might lead to a slight performance penalty compared to frozen objects in optimized JS engines.

### Benchmark Results
The results show that both the frozen object and the non-frozen object have very close execution speeds:
- **Loop frozen object**: 5,165,897.5 executions per second.
- **Loop non-frozen object**: 5,155,683.0 executions per second.

This indicates that, at least in this specific benchmark context, there is negligible difference in performance between looping through a frozen vs. non-frozen object.

### Alternatives
- **Using Map or Set**: Depending on use cases, one might consider using `Map` or `Set` objects for collections of data, which provide more control over properties and can optimize performance in certain scenarios.
- **Immutable.js**: For complex applications where immutability is crucial, using libraries like Immutable.js can help in managing immutable data structures efficiently and more conveniently than using basic JavaScript objects.
- **Frozen Prototypes**: Instead of freezing individual objects, one can create a prototype chain that leads to frozen objects, which allows certain levels of mutability in derived objects.

Overall, selecting between frozen and non-frozen objects should depend on specific use cases that align with application requirements, requiring careful consideration of the trade-offs involved.

Related benchmarks:

Looping frozen object vs non-frozen object (version: 1)

Comparing performance of: Loop frozen object vs Loop non-frozen object

Created: 3 days ago by: Guest

Jump to the latest result

Loop frozen object

Loop non-frozen object

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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