Benchmark: Object.freeze vs Object.seal

Script Preparation code:

var normal = {
  x: 0,
  y: 0
};
var freeze = Object.freeze({
  x: 0,
  y: 0
});
var seal = Object.seal({
  x: 0,
  y: 0
});

Tests:

normal
var t = normal.x; normal.x = normal.y; normal.y = t;
freeze
var t = freeze.x; freeze.x = freeze.y; freeze.y = t;
seal
var t = seal.x; seal.x = seal.y; seal.y = t;

Historical Performance Data aggregated from 39 community runs

Desktop Results:

Chrome 27 runs

seal

6.5M/s

normal

6.2M/s

freeze

1.2M/s

Fastest: seal (5.6x faster)

View exact numbers

✓ seal: 6,458,993 ops/sec
• normal: 6,172,505 ops/sec
• freeze: 1,158,899 ops/sec

Firefox 12 runs

seal

407.8M/s

normal

407.7M/s

freeze

17.0M/s

Fastest: seal (24.1x faster)

View exact numbers

✓ seal: 407,760,864 ops/sec
• normal: 407,725,248 ops/sec
• freeze: 16,954,620 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
normal
freeze
seal

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 8 months ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:145.0) Gecko/20100101 Firefox/145.0

Browser/OS: Firefox 145 on Linux

View result in a separate tab

seal

449.8M/s

normal

446.9M/s

freeze

18.4M/s

View exact numbers

Test name	Executions per second
✓ seal	449,828,640 Ops/sec
normal	446,934,624 Ops/sec
freeze	18,357,344 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and the pros/cons of each approach.

**Benchmark Overview**

The benchmark compares the performance of three JavaScript objects: `normal`, `freeze`, and `seal`. All three objects have two properties, `x` and `y`, initialized to 0. The benchmark is designed to test how fast each object can be modified.

**Test Cases**

There are three test cases:

1. **Normal Object**: The benchmark starts by assigning a value to `normal.x` (i.e., `t = normal.x;`) and then updating both `x` and `y` properties in sequence (i.e., `normal.y = t;`).
2. **Frozen Object**: Similar to the first test case, but this time the object is frozen using `Object.freeze()` before running the benchmark.
3. **Sealed Object**: Similar to the second test case, but this time the object is sealed using `Object.seal()` before running the benchmark.

**Library Used**

The library used in this benchmark is `Object`. Specifically, it uses the following methods:

* `Object.freeze()`: Creates a new frozen object by copying the specified object's properties and sealing them. The original object remains unchanged.
* `Object.seal()`: Creates a new sealed object by copying the specified object's properties and making some of them non-configurable (i.e., cannot be modified directly). Like `Object.freeze()`, the original object remains unchanged.

**Special JS Features/Syntax**

There are no special JavaScript features or syntax used in this benchmark, but it does use ES6+ syntax (`let` and `const`).

**Pros/Cons of Each Approach**

Here's a brief summary of each approach:

* **Normal Object (no modification)**: This is the baseline performance. Modifying an object requires creating a new one, which can be costly in terms of memory allocation.
	+ Pros: Easy to implement, doesn't require any special libraries or syntax.
	+ Cons: Can be slow for large objects due to frequent memory allocations.
* **Frozen Object (modified)**:
	+ Pros: Faster than normal objects since the object's properties are sealed and cannot be modified directly.
	+ Cons: If the object needs to be updated, it must first be thawed using `Object.parse()` or other methods, which can be slow.
* **Sealed Object (modified)**:
	+ Pros: Faster than normal objects since some of the object's properties are non-configurable and cannot be modified directly.
	+ Cons: If an attempted modification causes a runtime error, it can be slower than using a frozen object.

**Other Alternatives**

If you're looking for alternative approaches to benchmarking, consider:

* **Procedural programming**: Instead of creating objects, use arrays or other data structures to store and update values.
* **Prototype-based programming**: Create new objects by cloning existing ones instead of using `Object.create()` or similar methods.

Keep in mind that these alternatives may not provide the same level of control over object behavior as the approaches used in this benchmark.

Object.freeze vs Object.seal (version: 0)

Comparing performance of: `normal vs freeze vs seal`

Created: 7 years ago by: Guest

Go to the latest result

normal

freeze

seal

Historical Performance Data aggregated from 39 community runs

Desktop Results:

Chrome 27 runs

Firefox 12 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Object.freeze vs Object.seal (version: 0)

Comparing performance of: normal vs freeze vs seal

Created: 7 years ago by: Guest

Go to the latest result

normal

freeze

seal

Historical Performance Data aggregated from 39 community runs

Desktop Results:

Chrome 27 runs

Firefox 12 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `normal vs freeze vs seal`