Object.freeze() is described as shallow. What does that mean concretely, and how would you implement a deep freeze that handles an object graph containing cycles?

## What "shallow" actually means The freeze operation is defined over the target's own property *slots*, not over the values in them. It marks the object non-extensible and turns off `writable` and `configurable` on each own property. A property holding an object reference becomes a locked slot containing an unlocked object: ```js const cfg = Object.freeze({ db: { host: 'localhost', port: 5432 } }); cfg.db = {}; // fails — the slot is read-only cfg.db.host = 'evil'; // succeeds — the inner object was never frozen ``` That asymmetry is the whole trap. A reviewer sees `Object.freeze` at the top of a config module and assumes the tree is safe; only the first level is. The same applies to arrays of objects (`Object.freeze(list)` fixes the elements' identities, not their contents) and to prototypes: freezing an instance does not freeze `Object.getPrototypeOf(instance)`, so a shared method on the prototype can still be replaced. ## A correct deep freeze ```js function deepFreeze(value, seen = new WeakSet()) { if (value === null) return value; const t = typeof value; if (t !== 'object' && t !== 'function') return value; // primitives if (seen.has(value)) return value; // cycle guard seen.add(value); for (const key of Reflect.ownKeys(value)) { const desc = Object.getOwnPropertyDescriptor(value, key); if (desc && 'value' in desc) deepFreeze(desc.value, seen); } return Object.freeze(value); } ``` Four deliberate choices here: 1. **Cycle guard.** `a.self = a` would otherwise recurse until the stack overflows. A `WeakSet` records objects already entered; adding *before* recursing is what makes a self-reference terminate. An alternative guard is to call `Object.freeze(value)` first and then skip anything already `Object.isFrozen`, but that conflates "I visited it" with "someone froze it earlier", so a pre-frozen object with mutable children gets skipped. 2. **Descriptor reads, not `value[key]`.** Reading a property with `[]` triggers a getter, which may have side effects, may be expensive, or may return a fresh object each call that you would then pointlessly freeze. `'value' in desc` restricts the recursion to data properties and leaves accessors alone. 3. **`Reflect.ownKeys`** returns string *and* symbol keys, including non-enumerable ones — `Object.keys` would silently skip both, leaving parts of the graph mutable. 4. **Functions are objects too.** A function stored on the object has its own properties and can be extended; including `typeof value === 'function'` freezes those as well. This is optional and sometimes undesirable, since some libraries attach state to functions. ## What deep freeze still cannot reach Freezing is a property-level operation, so any state that does not live in properties survives: - **`Map`, `Set`, `WeakMap`, `Date`, typed arrays** keep their contents in internal slots. `Object.freeze(new Map()).set('k', 1)` works fine, and `date.setFullYear(2000)` still mutates a frozen `Date`. - **`#private` class fields** are not properties either; a method on a frozen instance can still increment `#count`. - **Closure state** captured by methods is untouched — that is the mechanism the module pattern relies on. - **Accessor properties** keep their setters, which can mutate anything they close over. If immutability of those matters, you need a different representation — plain objects and arrays rather than `Map`/`Date`, or a library with persistent data structures. ## Cost and alternatives Deep freezing walks the whole graph once, which is fine at module load for a config tree and wasteful in a hot path for large per-request data. Common patterns: - Deep-freeze **only in development** and skip it in production builds, treating it as a bug detector rather than a runtime guarantee. - Freeze at the boundary where an object becomes shared, not everywhere. - Prefer producing new objects (`{ ...old, k: v }`) so nothing needs freezing, and use freeze to catch violations of that discipline. A related note: `structuredClone` and `JSON.parse(JSON.stringify(x))` both produce fresh, *unfrozen* objects, so cloning a frozen tree gives you a mutable copy — occasionally what you want, occasionally a surprise. ## In an interview The expected answer is: name the shallowness, show the two-line demonstration, then write the recursive helper and, unprompted, mention the cycle guard and the getter problem. Those last two are what separates a memorized snippet from someone who has actually run it on real data.