How do you implement a deepFreeze function recursively?

Q: How do you implement a deepFreeze function recursively?

**Target Audience:** Engineers preparing for JavaScript fundamentals interviews. **Difficulty:** Medium > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every claim below — including the cycle-safety behavior — was actually run, not just reasoned about. ## 1. Why This Even Matters — A Story First Locking the front door of a house but leaving every internal room door wide open and unlocked technically means "the house is locked" — but anyone who gets inside can still freely rearrange every room. `Object.freeze()` locks only the front door — the top-level object's own properties — leaving every nested object's own "rooms" completely open unless each one is separately, deliberately locked too. ## 2. The Core Idea 📌 **Interview term:** `Object.freeze()` is genuinely shallow. A real, recursive `deepFreeze()` — with an `Object.isFrozen()` guard for cycle safety — freezes every nested level of an object graph.

The problem

Question presented to candidate: "You call Object.freeze() on a config object that has a nested object property. Can you still mutate that nested object? Write a deepFreeze() function that actually fixes this — and make sure it does not infinite-loop on a circular reference."

What a strong answer should cover:

📌 Interview term: the real, direct answer to the prompt — verified directly: yes — Object.freeze() is genuinely shallow. Freezing an object prevents changes to that object's OWN properties, but a NESTED object referenced by one of those properties is genuinely NOT itself frozen and remains fully mutable.
📌 Interview term: deepFreeze() — a real, recursive utility that calls Object.freeze() on the top-level object, then recurses into every property value that is itself an object or function, freezing each one too — verified directly to correctly prevent mutation at every nested level, including inside arrays.
📌 Interview term: the real cycle-safety requirement — a precise answer names that a naive recursive deepFreeze() would genuinely infinite-loop on a real, self-referential (circular) object — the fix is a real Object.isFrozen(obj) guard at the top of the recursive call: if an object is ALREADY frozen, return immediately rather than recursing into it again — verified directly to correctly terminate on a real cyclic structure.
📌 Interview term: Reflect.ownKeys() for full coverage — a precise answer names that iterating with Object.keys() alone would silently skip non-enumerable properties and Symbol-keyed properties; Reflect.ownKeys() (covered in more depth in this bank's own dedicated Proxy/Reflect question) correctly walks every own key, enumerable or not, string or Symbol.
A precise answer names the real, practical use case: freezing a shared configuration object or a Redux-style initial state tree so that an accidental deep mutation anywhere in the object graph genuinely throws (in strict mode) rather than silently corrupting shared state.

Clarifying questions expected:

None — this is an implementation question; directly writing and demonstrating the recursive fix (including the cycle-safety case) is the strong signal.

Code / implementation expected: Yes — a full, real, recursive deepFreeze() implementation, executed against a nested object, an array, and a genuinely circular structure.

objects
recursion
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: Medium

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every claim below — including the cycle-safety behavior — was actually run, not just reasoned about.

1. Why This Even Matters — A Story First

Locking the front door of a house but leaving every internal room door wide open and unlocked technically means "the house is locked" — but anyone who gets inside can still freely rearrange every room. Object.freeze() locks only the front door — the top-level object's own properties — leaving every nested object's own "rooms" completely open unless each one is separately, deliberately locked too.

2. The Core Idea

📌 Interview term: Object.freeze() is genuinely shallow. A real, recursive deepFreeze() — with an `Obje

The solution is hidden so you can try first

6 min read · 9 sections

Run the code

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

JavaScriptReal, direct proof: Object.freeze() is genuinely shallow, a recursive deepFreeze() fixes every nested level, and a real cyclic object is handled safely — verified directly