属性描述对象

Javascript提供了一个内部数据结构，用来描述对象的属性，控制它的行为，比如属性是否可写，可遍历等等。 这个内部数据结构称为“属性描述对象”。每个属性都有自己对应的属性描述对象，保存该属性的一些元信息。

下面是属性描述对象的一个例子

{
    value: 123,
    writable: false,
    enumerable: true,
    configurable: false,
    get: undefined,
    set: undefined
}

属性描述对象提供六个元属性：

（1）value
value是该属性的属性值，默认为undefined。

（2）writable
writable是一个布尔值，表示属性值（value）是否可改变（即是否可写），默认为true。

（3）enumerable
enumerable是一个布尔值，表示该属性是否可遍历，默认为true。如果设为false，
会使得某些操作（比如for...in循环、Object.keys()）跳过该属性。

（4）configurable
configurable是一个布尔值，表示可配置性，默认为true。如果设为false，将阻止某些操作改写该属性，
比如无法删除该属性，也不得改变该属性的属性描述对象（value属性除外）。
也就是说，configurable属性控制了属性描述对象的可写性。

（5）get

get是一个函数，表示该属性的取值函数（getter），默认为undefined。

（6）set

set是一个函数，表示该属性的存值函数（setter），默认为undefined。

Object.getOwnPropertyDescriptor()

Object.getOwnPropertyDescriptor方法获取obj.name的属性描述对象。
var obj = {name:'hello'}
Object.getOwnPropertyDescriptor(obj,'name');
//输出为下：
{
    configurable:true
    enumerable:true
    value:"hello"
    writable:true
}
注意，Object.getOwnPropertyDescriptor方法只能用于对象自身的属性，不能用于继承的属性。
var obj = { p: 'a' };

Object.getOwnPropertyDescriptor(obj, 'toString')
// undefined

toString是Obj对象继承的属性，Object.getOwnPropertyDescriptor无法获取。

Object.getOwnPropertyDescriptor方法可以获取属性描述对象。它的第一个参数是一个对象，第二个参数是一个字符串，对应该对象的某个属性名。

Object.getOwnPropertyNames()

var obj2 = {name:'hdjshf',age:23,sex:'man'};
Object.getOwnPropertyNames(obj2);

//['name','age','sex']

Object.getOwnPropertyNames方法返回一个数组，成员是参数对象自身的全部属性的属性名，不管该属性是否可遍历。

这跟Object.keys的行为不同，Object.keys只返回对象自身的可遍历属性的全部属性名。

Object.keys([]) // []
Object.getOwnPropertyNames([]) // [ 'length' ]

Object.keys(Object.prototype) // []
Object.getOwnPropertyNames(Object.prototype)
// ['hasOwnProperty',
//  'valueOf',
//  'constructor',
//  'toLocaleString',
//  'isPrototypeOf',
//  'propertyIsEnumerable',
//  'toString']

上面代码中，数组自身的length属性是不可遍历的，Object.keys不会返回该属性。第二个例子的Object.prototype也是一个对象，所有实例对象都会继承它，它自身的属性都是不可遍历的。

Object.defineProperty()，Object.defineProperties()

Object.defineProperty()方法允许通过属性描述对象，定义或修改一个属性，然后返回修改后的对象。用法如下：

Object.defineProperty(object, propertyName, attributesObject)

Object.defineProperty()方法，接受三个参数：

属性所在的对象，
属性名（应该是个字符串）
属性描述对象

例子：

var obj = Object.defineProperty({}, 'p', {
  value: 123,
  writable: false,
  enumerable: true,
  configurable: false
});

obj.p // 123

obj.p = 246;
obj.p // 123

Object.defineProperty(obj,'age',{value:18});
obj.age
//18

上面代码中，Object.defineProperty方法定义了obj.p属性。由于属性描述对象的writable属性为false，所以obj.p属性不可写。注意，这里的Object.defineProperty方法的第一个参数是{}（一个新建的空对象），p属性直接定义在这个空对象上面，然后返回这个对象，这是Object.defineProperty的常见写法。

如果属性已经存在，Object.defineProperty方法相当于更新该属性的属性描述对象。

如果一次性要修改多个：

var obj = Object.defineProperties({}, {
  p1: { value: 123, enumerable: true },
  p2: { value: 'abc', enumerable: true },
  p3: { get: function () { return this.p1 + this.p2 },
    enumerable:true,
    configurable:true
  }
});

obj.p1 // 123
obj.p2 // "abc"
obj.p3 // "123abc"

上面代码中，Object.defineProperties同时定义了obj对象的三个属性。其中，p3属性定义了取值函数get，即每次读取该属性，都会调用这个取值函数。

!!注意： 一旦定义了取值函数 get(或存值函数set),就不能将writable属性设置为true了，或者同时定义value属性,否则会报错。

var obj = {};

Object.defineProperty(obj, 'p', {
  value: 123,
  get: function() { return 456; }
});
// TypeError: Invalid property.
// A property cannot both have accessors and be writable or have a value

Object.defineProperty(obj, 'p', {
  writable: true,
  get: function() { return 456; }
});
// TypeError: Invalid property descriptor.
// Cannot both specify accessors and a value or writable attribute

Object.defineProperty()和Object.defineProperties()的第三个参数，是一个属性对象。它的writable、configurable、enumerable这三个属性的默认值都为false。

var obj = {};
Object.defineProperty(obj, 'foo', {});
Object.getOwnPropertyDescriptor(obj, 'foo')
// {
//   value: undefined,
//   writable: false,
//   enumerable: false,
//   configurable: false
// }
上面代码中，定义obj.p时用了一个空的属性描述对象，就可以看到各个元属性的默认值。

Object.prototype.propertyIsEnumerable()

实例对象的prototype.propertyIsEnumerable()方法返回一个布尔值，用来判断某个属性是否可遍历。

var obj = {};
obj.p = 123;

obj.propertyIsEnumerable('p') // true
obj.propertyIsEnumerable('toString') // false
上面代码中，obj.p是可遍历的，而继承自原型对象的obj.toString属性是不可遍历的。

元属性

属性描述对象的各个属性称为元属性，因为他们可以看作是控制属性的属性

value

value属性是目标属性的值。

var obj  = {};
obj.name = 'wuyanzu';

Object.getOwnPropertyDescriptor(obj,'name').value; //wuyanzu
Object.defineProperty(obj,'name',{value: 'huge'}); //obj.name  huge

上面代码是通过value属性，读取或改写obj.name的例子。

writable

注意！！： 如果原型对象的某个属性的writable为false，那么子对象将无法自定义这个属性。

var protoObj = Object.defineProperty({}, 'name',{
    value: '五月天',
    writable: false
});

var obj = Object.create(protoObj);
obj.name = 'hhaha';
obj.name //五月天 不变，因为子对象再无法自定义这个属性。
上面代码中，原型对象protoObj的name属性不可写， obj对象继承protoObj，也不可以再自定义这个属性了。
如果是严格模式，再自定义这个属性将会抛出错误

但是有一个可以规避这个，就是通过覆盖属性描述对象，绕过这个限制，原因是这种情况下，原型链会被完全忽视。

var proto = Object.defineProperty({}, 'foo', {
  value: 'a',
  writable: false
});

var obj = Object.create(proto);
Object.defineProperty(obj, 'foo', {
  value: 'b'
});

obj.foo // "b"

enumerable（可遍历性）

javascript的早期版本 for...in循环是基于in运算符的，in运算符不管某个属性是对象自身的还是继承的都会返回true.

var obj = {};
'toString' in obj // true

上面代码中，toString不是obj对象自身的属性，但是in运算符也返回true，这导致了toString属性也会被for...in循环遍历。 这显然不太合理，后来就引入了“可遍历性”这个概念。只有可遍历的属性，才会被for...in循环遍历，同时还规定toString这一类实例对象继承的原生属性，都是不可遍历的，这样就保证了for...in循环的可用性。

具体来说，如果一个属性的enumerable为false，下面三个操作不会取到该属性

for..in循环
Object.keys方法
JSON.stringify方法

因此，enumerable可以用来设置“秘密”属性

var obj = {};

Object.defineProperty(obj, 'x', {
  value: 123,
  enumerable: false
});

obj.x // 123

for (var key in obj) {
  console.log(key);
}
// undefined

Object.keys(obj)  // []
JSON.stringify(obj) // "{}"
上面代码中，obj.x属性的enumerable为false，所以一般的遍历操作都无法获取该属性，使得它有点像“秘密”属性
，但不是真正的私有属性，还是可以直接获取它的值。

注意，for...in循环包括继承的属性，Object.keys方法不包括继承的属性。如果需要获取对象自身的所有属性，
不管是否可遍历，可以使用Object.getOwnPropertyNames方法。

另外，JSON.stringify方法会排除enumerable为false的属性，有时可以利用这一点。
如果对象的 JSON 格式输出要排除某些属性，就可以把这些属性的enumerable设为false。

configurable

configurable(可配置性）返回一个布尔值，决定了是否可以修改属性描述对象。也就是说，configurable为false时，value、writable、enumerable和configurable都不能被修改了。

注意，writable只有在false改为true会报错，true改为false是允许的. 至于value，只要writable和configurable有一个为true，就允许改动。 另外，configurable为false时，直接目标属性赋值，不报错，但不会成功

可配置性决定了目标属性是否可以被删除（delete）。

var obj = Object.defineProperties({}, {
  p1: { value: 1, configurable: true },
  p2: { value: 2, configurable: false }
});

delete obj.p1 // true
delete obj.p2 // false

obj.p1 // undefined
obj.p2 // 2
上面代码中，obj.p1的configurable是true，所以可以被删除，obj.p2就无法删除。

存取器

除了直接定义，属性还可以用存取器定义。其中存值函数为setter,使用属性描述对象的set属性；取值函数为getter，使用属性描述对象get属性。

一旦为目标属性定义了存取器，那么存取的时候，都将执行对应的函数，

var obj = Object.defineProperty({}, 'p', {
  get: function () {
    return 'getter';
  },
  set: function (value) {
    console.log('setter: ' + value);
  }
});

obj.p // "getter"
obj.p = 123 // "setter: 123"
上面代码中，obj.p定义了get和set属性。obj.p取值时，就会调用get；赋值时，就会调用set。

JavaScript 还提供了存取器的另一种写法

var obj = {
  get p() {
    return 'getter';
  },
  set p(value) {
    console.log('setter: ' + value);
  }
};

注意，取值函数get不能接受参数，存值函数set只能接受一个参数（即属性的值）。

存取器往往用于，属性的值依赖对象内部数据的场合。

var obj ={
  $n : 5,
  get next() { return this.$n++ },
  set next(n) {
    if (n >= this.$n) this.$n = n;
    else throw new Error('新的值必须大于当前值');
  }
};

obj.next // 5

obj.next = 10;
obj.next // 10

obj.next = 5;
// Uncaught Error: 新的值必须大于当前值

上面代码中，next属性的存值函数和取值函数，都依赖于内部属性$n。

对象的拷贝

有时，我们需要将一个对象的所有属性，拷贝到另一个对象，可以用下面的方法实现。

var extend = function(toObj,fromObj) {
    for (var key in fromObj) {
        toObj[key] = fromObj[key]
    }
    return toObj
}
extend({},{a:1});//{a:1}

但是这种方法存在的缺陷是，如果遇上存取器定义的属性，会只拷贝值

extend({}, {
  get a() { return 1 }
})
// {a: 1}

为了解决这个问题，我们可以通过Object.defineProperty方法来拷贝属性。

var extend = function (to, from) {
  for (var property in from) {
    if (!from.hasOwnProperty(property)) continue;
    Object.defineProperty(
      to,
      property,
      Object.getOwnPropertyDescriptor(from, property)
    );
  }

  return to;
}

extend({}, { get a(){ return 1 } })
// { get a(){ return 1 } })

上面代码中，hasOwnProperty那一行用来过滤掉继承的属性，否则会报错，因为Object.getOwnPropertyDescriptor读不到继承属性的属性描述对象。

var extend = function (to, from) {
  for (var property in from) {
    if (!from.hasOwnProperty(property)) continue;
    Object.defineProperty(
      to,
      property,
      Object.getOwnPropertyDescriptor(from, property)
    );
  }

  return to;
}

extend({}, { get a(){ return 1 } })
// { get a(){ return 1 } })

上面代码中，hasOwnProperty那一行用来过滤掉继承的属性，否则会报错，因为Object.getOwnPropertyDescriptor读不到继承属性的属性描述对象。

控制对象状态

有时需要冻结对象的读写状态，防止对象被改变。JavaScript 提供了三种冻结方法，最弱的一种是Object.preventExtensions，其次是Object.seal，最强的是Object.freeze。

Object.preventExtensions方法可以使得一个对象无法再添加新的属性。

var obj = new Object();
Object.preventExtensions(obj);

Object.defineProperty(obj, 'p', {
  value: 'hello'
});
// TypeError: Cannot define property:p, object is not extensible.

obj.p = 1;
obj.p // undefined

Object.isExtensible()

Object.isExtensible方法用于检查一个对象是否使用了Object.preventExtensions方法。也就是说，检查是否可以为一个对象添加属性。

var obj = new Object();

Object.isExtensible(obj) // true
Object.preventExtensions(obj);
Object.isExtensible(obj) // false

Object.seal()

Object.seal方法使得一个对象既无法添加新属性，也无法删除旧属性。

var obj = { p: 'hello' };
Object.seal(obj);

delete obj.p;
obj.p // "hello"

obj.x = 'world';
obj.x // undefined

上面代码中，obj对象执行Object.seal方法以后，就无法添加新属性和删除旧属性了。

在控制器中执行代码
console.log(Object.getOwnPropertyDescriptor(obj,'p'));

发现p属性的属性描述对象中的configurable属性值为false
Object.seal实质是把属性描述对象的configurable属性设为false，因此属性描述对象不再能改变了。
Object.seal只是禁止新增或删除属性，并不影响修改某个属性的值。

var obj = { p: 'a' };
Object.seal(obj);
obj.p = 'b';
obj.p // 'b'

上面代码中，Object.seal方法对p属性的value无效，是因为此时p属性的可写性由writable决定。

Object.isSealed()

Object.isSealed()方法用于检查一个对象是否使用了Object.seal方法。

var obj = { p: 'a' };

Object.seal(obj);
Object.isSealed(obj) // true

Object.freeze()

Object.freeze方法可以使得一个对象无法添加新属性、无法删除旧属性、也无法改变属性的值，使得这个对象实际上变成了常量。

var obj = {
  p: 'hello'
};

Object.freeze(obj);

obj.p = 'world';
obj.p // "hello"

obj.t = 'hello';
obj.t // undefined

delete obj.p // false
obj.p // "hello"

Object.isFrozen()

Object.isFrozen()方法用于检查一个对象是否使用了Object.freeze方法。

使用Object.freeze方法以后，Object.isSealed将会返回true，Object.isExtensible返回false。

局限性

1. 如果属性值是对象，上面这些方法只能冻结属性指向的对象，而不能冻结对象本身的内容。

var obj = {
  foo: 1,
  bar: ['a', 'b']
};
Object.freeze(obj);

obj.bar.push('c');
obj.bar // ["a", "b", "c"]
上面代码中，obj.bar属性指向一个数组，obj对象被冻结以后，这个指向无法改变，即无法指向其他值，但是所指向的数组是可以改变的。

2. 第二个漏洞是，虽然结了该对象，但是可以在对象的原型上添加新对象，这个破解方法就是把原型也冻住