当前位置：首页 > 文章列表 > 文章 > 前端 > 判断对象是否被冻结的方法

判断对象是否被冻结的方法

2025-11-27 10:04:46 0浏览收藏

文章小白一枚，正在不断学习积累知识，现将学习到的知识记录一下，也是将我的所得分享给大家！而今天这篇文章《如何判断对象原型是否被冻结》带大家来了解一下##content_title##，希望对大家的知识积累有所帮助，从而弥补自己的不足，助力实战开发！

要判断一个对象的原型是否被冻结，需先用Object.getPrototypeOf()获取原型，再用Object.isFrozen()检查；1. Object.isFrozen()返回true当且仅当对象不可扩展、所有属性不可配置、所有数据属性不可写；2. 冻结原型可确保实例共享的方法和属性不被修改，但仅浅冻结；3. 其他保护机制包括Object.preventExtensions()（不可扩展）、Object.seal()（不可扩展且属性不可配置）、const（变量绑定不可变）和私有类字段（#前缀实现封装）；这些方法按保护强度递增，应根据需求选择合适的对象保护策略。

js如何判断对象的原型是否被冻结

在 JavaScript 中，要判断一个对象的原型是否被冻结，你需要获取到这个对象的原型，然后对原型对象本身使用 Object.isFrozen() 方法。这其实是一个很直接的思路，但有时候人们会混淆是判断对象自身还是它的原型。

要判断一个对象的原型是否被冻结，核心在于两步：先用 Object.getPrototypeOf() 拿到原型对象，再用 Object.isFrozen() 去检查它。

// 定义一个普通对象
const myObject = {};

// 获取 myObject 的原型，通常是 Object.prototype
const protoOfMyObject = Object.getPrototypeOf(myObject);

// 检查这个原型对象是否被冻结
const isProtoFrozen = Object.isFrozen(protoOfMyObject);

console.log(`myObject 的原型是否被冻结？${isProtoFrozen}`); // 通常会是 true，因为 Object.prototype 是被冻结的

// 假设我们有一个自定义构造函数
function MyClass() {}
const instance = new MyClass();
const protoOfInstance = Object.getPrototypeOf(instance); // 也就是 MyClass.prototype

// 冻结 MyClass 的原型
Object.freeze(MyClass.prototype);

const isMyClassProtoFrozen = Object.isFrozen(protoOfInstance);
console.log(`MyClass 的原型是否被冻结？${isMyClassProtoFrozen}`); // 应该是 true

// 尝试修改被冻结的原型，会失败或报错（严格模式下）
try {
  MyClass.prototype.newMethod = function() {};
} catch (e) {
  console.error("尝试修改冻结的原型失败：", e.message);
}

// 即使原型被冻结，实例本身依然可以添加属性
instance.myProp = 'hello';
console.log(instance.myProp); // 'hello'

这段代码清楚地展示了如何操作。关键在于区分实例和实例的原型。Object.isFrozen() 关注的是一个对象本身的属性描述符（可写、可配置、可扩展性），而不是它原型链上的状态。

Object.isFrozen() 到底检查了哪些状态？

Object.isFrozen() 这个方法，我觉得很多人可能只是知道它“冻结”了，但具体冻结了什么，可能没那么清晰。它其实是检查了三件事，而且必须同时满足这三点，一个对象才会被认为是“冻结”的：

不可扩展（Non-extensible）：这意味着你不能再给这个对象添加新的属性。就好像给房子加盖一样，冻结后就不允许了。Object.preventExtensions() 就能做到这一点。
所有现有属性都不可配置（All existing properties are non-configurable）：这意味着你不能改变这些属性的描述符（比如把 writable 从 true 改成 false），也不能删除这些属性。就像你家里的家具，一旦摆好就不能动了，也不能扔掉。
所有现有数据属性都不可写（All existing data properties are non-writable）：这意味着你不能修改这些属性的值。比如你墙上的画，一旦挂上就不能再换内容了。这和 Object.defineProperty() 设置 writable: false 类似。

所以，当 Object.isFrozen() 返回 true 时，这个对象就像被彻底“固化”了一样，它的结构和内容都不能再被修改了。这对于确保某些核心配置或共享工具的稳定性非常有用。

冻结一个对象或其原型，究竟意味着什么？

冻结一个对象，或者它的原型，这背后的意义远不止是代码层面的一个方法调用。我觉得它更多的是关于不变性（Immutability）和共享安全性的思考。

当你 Object.freeze() 一个对象时，你是在说：“这个对象，从现在开始，它的结构和所有属性的值都不能再被外部直接修改了。” 这对于那些作为配置、常量或者跨模块共享的数据结构来说，简直是福音。想想看，如果你的一个核心配置对象在某个地方被不小心改了，那整个应用可能都会出问题。冻结它，能有效避免这类“副作用”。

而冻结原型，则更深一层。原型是所有实例共享的基础。如果一个构造函数的原型被冻结了，那么所有通过这个构造函数创建的实例，它们继承自原型的方法和属性，就都不能被修改或删除了。这对于构建稳定的类库、框架或者确保核心业务逻辑的稳固性至关重要。比如，你发布一个组件库，不希望用户通过“猴子补丁”（monkey patching）的方式去随意修改你的组件原型上的核心方法，那样可能会导致难以预料的行为。冻结原型，就像是给你的组件核心能力加上了一把锁。

但也要注意，Object.freeze() 只是浅冻结。如果一个对象属性的值是另一个对象，那个嵌套的内部对象是不会被冻结的。所以，如果你需要深度的不可变性，可能需要自己实现一个递归的冻结函数，或者使用像 Immutable.js 这样的库。

除了冻结，还有哪些方法可以保护 JavaScript 对象的结构？

JavaScript 提供了几种不同的机制来控制对象的“可变性”，它们各有侧重，就像是不同程度的锁，而不是只有“冻结”这一种极限操作。我觉得理解这些不同的保护方式，能让我们在设计系统时更加灵活。

Object.preventExtensions(): 这是最宽松的一种保护。它仅仅是让一个对象变得不可扩展，也就是说，你不能再给它添加新的属性了。但是，已有的属性依然可以被修改（如果它们是可写的）或者删除（如果它们是可配置的）。这就像是给房子设了个“停建令”，不能加盖，但里面的装修和家具还是可以动的。
```
const myConfig = { version: '1.0' };
Object.preventExtensions(myConfig);
myConfig.version = '1.1'; // 可以修改
console.log(myConfig.version); // '1.1'
myConfig.newProp = 'value'; // 会失败或报错
console.log(Object.isExtensible(myConfig)); // false
```
Object.seal(): 这个方法比 preventExtensions 更进一步。它不仅让对象不可扩展，还会把所有现有属性标记为不可配置。这意味着你不能删除现有属性，也不能改变它们的属性描述符（比如从可写变为不可写）。但是，如果属性是可写的，你仍然可以修改它们的值。这就像是把房子封顶了，不能加盖，里面的家具也不能扔掉或换位置，但家具本身的内容（比如电视里播放的节目）还是可以变的。
```
const user = { name: 'Alice', age: 30 };
Object.seal(user);
user.age = 31; // 可以修改
console.log(user.age); // 31
delete user.name; // 会失败或报错
user.email = 'a@example.com'; // 会失败或报错
console.log(Object.isSealed(user)); // true
```
使用 const 声明变量: 虽然 const 声明的变量不能被重新赋值，但它只保护了变量名到值的绑定，而不是值本身。如果这个值是一个对象，对象的属性仍然是可以被修改的。这更像是给一个盒子贴了标签，标签不能换，但盒子里的东西还是可以动的。
```
const settings = { theme: 'dark' };
settings.theme = 'light'; // 可以修改对象内部属性
console.log(settings.theme); // 'light'
// settings = {}; // 报错，不能重新赋值
```

私有类字段（Private Class Fields）: 这是 ES2022 引入的特性，通过在属性名前加 # 来定义。私有字段只能在类的内部访问和修改，外部无法直接触及。这是一种非常强力的封装机制，可以有效保护对象的内部状态不被外部代码随意篡改。它不是关于“冻结”，而是关于“隐藏”和“封装”。

class Account {
  #balance; // 私有字段

  constructor(initialBalance) {
    this.#balance = initialBalance;
  }

  deposit(amount) {
    this.#balance += amount;
  }

  getBalance() {
    return this.#balance;
  }
}

const myAccount = new Account(100);
// console.log(myAccount.#balance); // 语法错误，外部无法访问
myAccount.deposit(50);
console.log(myAccount.getBalance()); // 150

选择哪种保护机制，取决于你对对象可变性的需求。有时候只需要防止意外添加属性，有时候需要完全的不可变性，而私有字段则更侧重于封装和信息隐藏。理解这些差异，才能更好地设计健壮的 JavaScript 应用。

今天关于《判断对象是否被冻结的方法》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！