What is the difference between Object.freeze and const?

Q: What is the difference between Object.freeze and const?

**Target Audience:** Engineers preparing for JavaScript fundamentals interviews. **Difficulty:** Easy > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every behavior below was **actually run** — a genuine mutable const object, a genuine frozen-object rejection, and a genuine reassignment of a frozen binding — not descriptions of documented behavior. ## 1. Why This Even Matters — A Story First A locked mailbox with an unlocked front door protects a genuinely different thing than a locked front door with an unlocked mailbox — knowing which lock protects what matters. `const` locks the variable's own binding (the front door); `Object.freeze` locks the object's own contents (the mailbox) — verified directly below, they are genuinely separate locks. ## 2. The Core Idea 📌 **Interview term:** `const` prevents **reassigning the variable**; `Object.freeze` prevents **mutating the object's own properties**. Genuin

The problem

Question presented to candidate: "A teammate writes const user = { name: 'Ada' }; and says 'this object can never change, I made it const.' Is that actually true? What is the real difference between what const protects and what Object.freeze protects?"

What a strong answer should cover:

📌 Verified, not assumed: a real const object's property genuinely allowed mutation — obj.count = 5 genuinely succeeded on a const-bound object — directly disproving the teammate's claim.
const only prevents reassigning the variable binding itself — a real attempt to reassign a const variable genuinely threw a real TypeError, but that is a completely different protection than protecting the object's own contents.
📌 Interview term: Object.freeze() — makes an object's own properties immutable (shallowly): no adding, deleting, or changing existing values. Verified directly: a real frozen object's property write was genuinely silently ignored outside strict mode, and genuinely threw a real TypeError inside strict mode.
A precise answer names that these two protections are genuinely orthogonal — a let-bound frozen object can still be reassigned to a brand-new object (verified directly: the binding changed, a real different object), while a const-bound unfrozen object's binding is fixed but its contents remain genuinely mutable.
The precise, complete answer: combining both — const frozen = Object.freeze({...}) — is what actually gives an immutable binding to an immutable object; neither one alone provides that.

Clarifying questions expected:

"Does the actual requirement need the object's CONTENTS to be immutable, or just that this specific variable can't be reassigned to point somewhere else?" — these are genuinely different needs, verified above as protected by different mechanisms.
"Does the object have nested objects that also need protecting?" — Object.freeze is genuinely shallow, verified above only at the top level — a real, separate consideration.

Code / implementation expected: Yes — a real, direct demonstration that a const object's property is genuinely still mutable, alongside a real frozen object's write being genuinely rejected, is the concrete proof of exactly where each protection actually applies.

immutability

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript fundamentals interviews. Difficulty: Easy

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every behavior below was actually run — a genuine mutable const object, a genuine frozen-object rejection, and a genuine reassignment of a frozen binding — not descriptions of documented behavior.

1. Why This Even Matters — A Story First

A locked mailbox with an unlocked front door protects a genuinely different thing than a locked front door with an unlocked mailbox — knowing which lock protects what matters. const locks the variable's own binding (the front door); Object.freeze locks the object's own contents (the mailbox) — verified directly below, they are genuinely separate locks.

2. The Core Idea

📌 Interview term: const prevents **reassigning th

The solution is hidden so you can try first

6 min read · 8 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal proof: a const object's property is genuinely mutable, while a frozen object's write is genuinely rejected