​​Object.freeze(obj)​​

  • 可以冻结一个对象。一个被冻结的对象再也不能被修改；
  • 冻结了一个对象则不能向这个对象添加新的属性，不能删除已有属性，
  • 不能修改该对象已有属性的可枚举性、可配置性、可写性，以及不能修改已有属性的值。
  • 冻结一个对象后该对象的原型也不能被修改。
  • ​​freeze()​​ 返回和传入的参数相同的对象。
  • 返回值：被冻结的对象。

冻结对象

未冻结

var obj = {
    prop: function () {
    },
    foo: 'bar'
}
// 新的属性会被添加, 已存在的属性可能会被修改或移除
obj.foo = 'baz'
obj.lumpy = 'woof' // Object {foo: "baz", lumpy: "woof", prop: function}
delete obj.prop // Object {foo: "baz", lumpy: "woof"}

作为参数传递的对象与返回的对象都被冻结，所以不必保存返回的对象（因为两个对象全等）

var o = Object.freeze(obj)
o === obj // true
Object.isFrozen(obj) // === true

 现在任何改变都会失效

obj.foo = 'quux' // 静默地不做任何事 Object {foo: "baz", lumpy: "woof"}
obj.quaxxor = 'the friendly duck' // 静默地不添加此属性

在严格模式，如此行为将抛出 TypeErrors

function fail () {
    'use strict'
    obj.foo = 'sparky' // throws a TypeError
    delete obj.quaxxor // 返回true，因为quaxxor属性从来未被添加
    obj.sparky = 'arf' // throws a TypeError
}
fail()

试图通过 Object.defineProperty 更改属性，会抛出 TypeError.

Object.defineProperty(obj, 'ohai', {value: 17})
Object.defineProperty(obj, 'foo', {value: 'eit'})

不能更改原型，会抛出 TypeError.

Object.setPrototypeOf(obj, {x: 20})
obj.__proto__ = {x: 20}

冻结数组

let a = [0]
Object.freeze(a) // 现在数组不能被修改了.
a[0] = 1 // TypeError
a.push(2) // TypeError
function fail () { // TypeError
    'use strict'
    a[0] = 1
    a.push(2)
}
fail()

浅冻结

被冻结的对象是不可变的。但也不总是这样。下例展示了冻结对象不是常量对象。

obj1 = {
    internal: {}
}
Object.freeze(obj1)
obj1.internal.a = 'aValue'
console.log(obj1.internal.a) // 'aValue'

深冻结

// 深冻结函数.
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

Object.freeze(obj)  深冻结对象_spark