Object.freeze() 方法冻结对象、Object.seal()方法封闭对象、Object.preventExtensions()方法象不可扩展

冷不防 2023-02-19 11:25 48阅读 0赞

### 1、**Object.isExtensible()和Object.preventExtensions() ——对象不可拓展** ###

`Object.isExtensible()` 方法判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。返回一个Boolean值。

默认情况下，对象是可扩展的：即可以为他们添加新的属性。以及它们的 [`__proto__`][proto] 属性可以被更改。[`Object.preventExtensions`][Object.preventExtensions]，[`Object.seal`][Object.seal] 或 [`Object.freeze`][Object.freeze] 方法都可以标记一个对象为不可扩展（non-extensible）

新对象默认是可扩展的.
    var empty = {};
    Object.isExtensible(empty);  === true
    
     ...可以变的不可扩展.
    Object.preventExtensions(empty);
    Object.isExtensible(empty);  === false
    
     密封对象是不可扩展的.
    var sealed = Object.seal({});
    Object.isExtensible(sealed);  === false
    
    冻结对象也是不可扩展.
    var frozen = Object.freeze({});
    Object.isExtensible(frozen);  === false

注意：

在 ES5 中，如果参数不是一个对象类型，将抛出一个 [`TypeError`][TypeError] 异常。

在 ES6 中， non-object 参数将被视为一个不可扩展的普通对象，因此会返回 false 。

Object.isExtensible(1);
    TypeError: 1 is not an object (ES5 code)
    
    Object.isExtensible(1);
    false                         (ES6 code)

`Object.preventExtensions()`方法让一个对象变的不可扩展，也就是永远不能再添加新的属性。返回已经不可扩展的该对象。

如果一个对象可以添加新的属性，则这个对象是可扩展的。`Object.preventExtensions()`将对象标记为不再可扩展，这样它将永远不会具有它被标记为不可扩展时持有的属性之外的属性。注意，一般来说，不可扩展对象的属性可能仍然可被*删除*。尝试将新属性添加到不可扩展对象将静默失败或抛出[`TypeError`][TypeError]（最常见的情况是[strict mode][]中，但不排除其他情况）。

`Object.preventExtensions()`仅阻止添加自身的属性。但其对象类型的原型依然可以添加新的属性。

该方法使得目标对象的 `[[prototype]]`  不可变；任何重新赋值 `[[prototype]]` 操作都会抛出 `TypeError` 。这种行为只针对内部的 `[[prototype]]` 属性， 目标对象的其它属性将保持可变。

一旦将对象变为不可扩展的对象，就再也不能使其可扩展。

在 ES5 中，如果参数不是一个对象类型（而是原始类型），将抛出一个[`TypeError`][TypeError]异常。在 ES2015 中，非对象参数将被视为一个不可扩展的普通对象，因此会被直接返回。

### **2、Object.isFrozen()和Object.freeze() ——冻结对象** ###

`Object.isFrozen()`方法判断一个对象是否被[冻结][Object.freeze]。返回Boolean值。

一个对象是冻结的是指它不可[`扩展`][Link 1]，所有属性都是不可配置的，且所有数据属性（即没有getter或setter组件的访问器的属性）都是不可写的。

// 一个对象默认是可扩展的,所以它也是非冻结的.
    Object.isFrozen({}); // === false
    
    // 一个不可扩展的空对象同时也是一个冻结对象.
    var vacuouslyFrozen = Object.preventExtensions({});
    Object.isFrozen(vacuouslyFrozen) //=== true;
    
    // 一个非空对象默认也是非冻结的.
    var oneProp = { p: 42 };
    Object.isFrozen(oneProp) //=== false
    
    // 让这个对象变的不可扩展,并不意味着这个对象变成了冻结对象,
    // 因为p属性仍然是可以配置的(而且可写的).
    Object.preventExtensions(oneProp);
    Object.isFrozen(oneProp) //=== false
    
    // 此时,如果删除了这个属性,则它会成为一个冻结对象.
    delete oneProp.p;
    Object.isFrozen(oneProp) //=== true
    
    // 一个不可扩展的对象,拥有一个不可写但可配置的属性,则它仍然是非冻结的.
    var nonWritable = { e: "plep" };
    Object.preventExtensions(nonWritable);
    Object.defineProperty(nonWritable, "e", { writable: false }); // 变得不可写
    Object.isFrozen(nonWritable) //=== false
    
    // 把这个属性改为不可配置,会让这个对象成为冻结对象.
    Object.defineProperty(nonWritable, "e", { configurable: false }); // 变得不可配置
    Object.isFrozen(nonWritable) //=== true
    
    // 一个不可扩展的对象,拥有一个不可配置但可写的属性,则它仍然是非冻结的.
    var nonConfigurable = { release: "the kraken!" };
    Object.preventExtensions(nonConfigurable);
    Object.defineProperty(nonConfigurable, "release", { configurable: false });
    Object.isFrozen(nonConfigurable) //=== false
    
    // 把这个属性改为不可写,会让这个对象成为冻结对象.
    Object.defineProperty(nonConfigurable, "release", { writable: false });
    Object.isFrozen(nonConfigurable) //=== true
    
    // 一个不可扩展的对象,值拥有一个访问器属性,则它仍然是非冻结的.
    var accessor = { get food() { return "yum"; } };
    Object.preventExtensions(accessor);
    Object.isFrozen(accessor) //=== false
    
    // ...但把这个属性改为不可配置,会让这个对象成为冻结对象.
    Object.defineProperty(accessor, "food", { configurable: false });
    Object.isFrozen(accessor) //=== true
    
    // 使用Object.freeze是冻结一个对象最方便的方法.
    var frozen = { 1: 81 };
    Object.isFrozen(frozen) //=== false
    Object.freeze(frozen);
    Object.isFrozen(frozen) //=== true
    
    // 一个冻结对象也是一个密封对象.
    Object.isSealed(frozen) //=== true
    
    // 当然,更是一个不可扩展的对象.
    Object.isExtensible(frozen) //=== false

在 ES5 中，如果参数不是一个对象类型，将抛出一个[`TypeError`][TypeError]异常。在 ES2015 中，非对象参数将被视为一个冻结的普通对象，因此会返回`true`。

**`Object.freeze()`** 方法可以**冻结**一个对象。

一个被冻结的对象再也不能被修改；冻结了一个对象则不能向这个对象添加新的属性，不能删除已有属性，不能修改该对象已有属性的可枚举性、可配置性、可写性，以及不能修改已有属性的值。

此外，冻结一个对象后该对象的原型也不能被修改。`freeze()` 返回和传入的参数相同的对象。**这个方法返回传递的对象，而不是创建一个被冻结的副本。**

被冻结对象自身的所有属性都不可能以任何方式被修改。任何修改尝试都会失败，无论是静默地还是通过抛出[`TypeError`][TypeError]异常（最常见但不仅限于[strict mode][strict mode 1]）。

数据属性的值不可更改，访问器属性（有getter和setter）也同样（但由于是函数调用，给人的错觉是还是可以修改这个属性）。如果一个**属性的值是个对象**，则**这个属性对象**中的属性是可以修改的，除非它也是个冻结对象。数组作为一种对象，被冻结，其元素不能被修改。没有数组元素可以被添加或移除。

**深冻结对象：**

// 深冻结函数.
    function deepFreeze(obj) {
    
      // 取回定义在obj上的属性名
      var propNames = Object.getOwnPropertyNames(obj);
    
      // 在冻结自身之前冻结属性
      propNames.forEach(function(name) {
        var prop = obj[name];
    
        // 如果prop是个对象，冻结它
        if (typeof prop == 'object' && prop !== null)
          deepFreeze(prop);
      });
    
      // 冻结自身(no-op if already frozen)
      return Object.freeze(obj);
    }
    
    obj2 = {
      internal: {}
    };
    
    deepFreeze(obj2);
    obj2.internal.a = 'anotherValue';
    obj2.internal.a; // undefined

在ES5中，如果这个方法的参数不是一个对象（一个原始值），那么它会导致 [`TypeError`][TypeError]。在ES2015中，非对象参数将被视为要被冻结的普通对象，并被简单地返回。

用`Object.seal()`密封的对象可以改变它们现有的属性。使用`Object.freeze()` 冻结的对象中现有属性是不可变的

### **3、Object.isSealed()和Object.seal()  ——密封对象** ###

**`Object.isSealed()`** 方法判断一个对象是否被密封。返回Boolean值。

如果这个对象是密封的，则返回 `true`，否则返回 `false`。密封对象是指那些不可 [`扩展`][Link 1] 的，且所有自身属性都不可配置且因此不可删除（但不一定是不可写）的对象。

// 新建的对象默认不是密封的.
    var empty = {};
    Object.isSealed(empty); // === false
    
    // 如果你把一个空对象变的不可扩展,则它同时也会变成个密封对象.
    Object.preventExtensions(empty);
    Object.isSealed(empty); // === true
    
    // 但如果这个对象不是空对象,则它不会变成密封对象,因为密封对象的所有自身属性必须是不可配置的.
    var hasProp = { fee: "fie foe fum" };
    Object.preventExtensions(hasProp);
    Object.isSealed(hasProp); // === false
    
    // 如果把这个属性变的不可配置,则这个对象也就成了密封对象.
    Object.defineProperty(hasProp, "fee", { configurable: false });
    Object.isSealed(hasProp); // === true
    
    // 最简单的方法来生成一个密封对象,当然是使用Object.seal.
    var sealed = {};
    Object.seal(sealed);
    Object.isSealed(sealed); // === true
    
    // 一个密封对象同时也是不可扩展的.
    Object.isExtensible(sealed); // === false
    
    // 一个密封对象也可以是一个冻结对象,但不是必须的.
    Object.isFrozen(sealed); // === true ，所有的属性都是不可写的
    var s2 = Object.seal({ p: 3 });
    Object.isFrozen(s2); // === false， 属性"p"可写
    
    var s3 = Object.seal({ get p() { return 0; } });
    Object.isFrozen(s3); // === true ，访问器属性不考虑可写不可写,只考虑是否可配置

`Object.seal()`方法封闭一个对象，阻止添加新属性并将所有现有属性标记为不可配置。当前属性的值只要原来是可写的就可以改变。返回被密封的对象，即被密封对象的引用。

通常，一个对象是[可扩展的][Link 1]（可以添加新的属性）。密封一个对象会让这个对象变的不能添加新属性，且所有已有属性会变的不可配置。属性不可配置的效果就是属性变的不可删除，以及一个数据属性不能被重新定义成为访问器属性，或者反之。但属性的值仍然可以修改。因为writable还是原本设置的，可能是true。数据属性的writable由定义时决定，普通的属性writable是true。

尝试删除一个密封对象的属性或者将某个密封对象的属性从数据属性转换成访问器属性都会失败，抛出异常。

不会影响从原型链上继承的属性。但 `__proto__（该属性还不是在所有浏览器通用的）` 属性的值也会不能修改。

[proto]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/proto
[Object.preventExtensions]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/preventExtensions
[Object.seal]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/seal
[Object.freeze]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
[TypeError]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/TypeError
[strict mode]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode
[Link 1]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/isExtensible
[strict mode 1]: https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Strict_mode