javascript 的 object.freeze() 只冻结当前对象,嵌套对象仍可能被修改。递归冻结普通数据对象时,可用 weakset 记录已访问引用,避免循环结构反复递归,再冻结每个对象。下面的实现限定普通对象和数组,拒绝访问器及 map、set、date 等对象,不宣称覆盖所有 javascript 类型。

先验证 Object.freeze 只冻结第一层
保存为 shallow.cjs 后用 Node.js 执行。严格模式下修改已冻结的顶层属性会抛 TypeError,但对未冻结的内层对象修改仍能成功。Object.isFrozen 也只检查传入的这个对象,不会递归验证整个对象图。
'use strict';
const assert = require('node:assert/strict');
const config = Object.freeze({ limit: 3, nested: { enabled: true } });
assert.throws(() => { config.limit = 9; }, TypeError);
config.nested.enabled = false;
assert.equal(config.nested.enabled, false);
assert.equal(Object.isFrozen(config), true);
assert.equal(Object.isFrozen(config.nested), false);
console.log('浅冻结边界验证通过');冻结会直接改变原对象的属性描述,不会创建副本。因此应先确定调用方允许修改这个对象的可变性,再执行递归冻结;复制需求与冻结需求应分别处理。
用 WeakSet 遍历循环引用并冻结全部数据属性
保存为 deep-freeze.cjs。本例先收集并验证所有节点,再统一冻结,避免遇到不支持的类型时,前面已经被部分冻结。通过属性描述符读取数据属性,可避免遍历过程自动执行 getter;不支持的访问器直接报错。
立即学习“Java免费学习笔记(深入)”;
'use strict';
function deepFreeze(root) {
const visited = new WeakSet();
const nodes = [];
function visit(value) {
if (value === null || (typeof value !== 'object' && typeof value !== 'function')) return;
if (typeof value === 'function') throw new TypeError('不支持函数节点');
if (visited.has(value)) return;
const proto = Object.getPrototypeOf(value);
if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) {
throw new TypeError('仅支持普通对象和数组');
}
visited.add(value);
nodes.push(value);
for (const key of Reflect.ownKeys(value)) {
const descriptor = Object.getOwnPropertyDescriptor(value, key);
if (!Object.hasOwn(descriptor, 'value')) {
throw new TypeError('不支持 getter/setter');
}
visit(descriptor.value);
}
}
visit(root);
for (const node of nodes) Object.freeze(node);
return root;
}
module.exports = { deepFreeze };此示例使用 Object.hasOwn,需使用支持该 API 的现代运行环境,例如 Node.js 18。Reflect.ownKeys 同时涵盖非枚举属性与 Symbol 键。已经浅冻结的对象也继续检查其子属性,不能因顶层已冻结就直接跳过。

检查循环引用、Symbol 属性和不支持的类型
保存为 check-freeze.cjs,与函数文件放在同一目录,执行 node check-freeze.cjs。测试既验证修改失败,也验证不支持的类型不会被误报为“深层不可变”。WeakSet 解决循环,但递归深度依然受调用栈限制。
'use strict';
const assert = require('node:assert/strict');
const { deepFreeze } = require('./deep-freeze.cjs');
const key = Symbol('extra');
const data = { nested: { value: 1 }, list: [1, 2], [key]: { count: 3 } };
data.self = data;
deepFreeze(data);
assert.equal(data.self, data);
assert.throws(() => { data.nested.value = 2; }, TypeError);
assert.throws(() => data.list.push(3), TypeError);
assert.throws(() => { data[key].count = 4; }, TypeError);
const shallow = Object.freeze({ inner: { value: 1 } });
deepFreeze(shallow);
assert.equal(Object.isFrozen(shallow.inner), true);
assert.throws(() => deepFreeze({ map: new Map() }), TypeError);
let getterCalls = 0;
const access = { get value() { getterCalls++; return {}; } };
assert.throws(() => deepFreeze(access), TypeError);
assert.equal(getterCalls, 0);
console.log('嵌套、循环、Symbol 与拒绝分支通过');Map、Set 等类型的内部数据不受普通属性冻结规则完全约束,不能简单调用 freeze 后就保证内容不可改。调用方还应排除 Proxy、跨上下文对象等复杂输入;此例只用于自己控制的普通数据结构。


















