JavaScript 标准库之属性描述对象

属性描述对象

[TOC]

概述

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

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

  1. {
  2. value: 123,
  3. writable: false,
  4. enumerable: true,
  5. configurable: false,
  6. get: undefined,
  7. set: undefined
  8. }

属性描述对象提供6个元属性。

(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()方法可以获取属性描述对象。它的第一个参数是目标对象,第二个参数是一个字符串,对应目标对象的某个属性名。

  1. var obj = { p: 'a' };
  2. Object.getOwnPropertyDescriptor(obj, 'p')
  3. // Object { value: "a",
  4. // writable: true,
  5. // enumerable: true,
  6. // configurable: true
  7. // }

上面代码中,Object.getOwnPropertyDescriptor()方法获取obj.p的属性描述对象。

注意,Object.getOwnPropertyDescriptor()方法只能用于对象自身的属性,不能用于继承的属性。

  1. var obj = { p: 'a' };
  2. Object.getOwnPropertyDescriptor(obj, 'toString')
  3. // undefined

上面代码中,toStringobj对象继承的属性,Object.getOwnPropertyDescriptor()无法获取。

Object.getOwnPropertyNames()

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

  1. var obj = Object.defineProperties({}, {
  2. p1: { value: 1, enumerable: true },
  3. p2: { value: 2, enumerable: false }
  4. });
  5. Object.getOwnPropertyNames(obj)
  6. // ["p1", "p2"]

上面代码中,obj.p1是可遍历的,obj.p2是不可遍历的。Object.getOwnPropertyNames会将它们都返回。

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

  1. Object.keys([]) // []
  2. Object.getOwnPropertyNames([]) // [ 'length' ]
  3. Object.keys(Object.prototype) // []
  4. Object.getOwnPropertyNames(Object.prototype)
  5. // ['hasOwnProperty',
  6. // 'valueOf',
  7. // 'constructor',
  8. // 'toLocaleString',
  9. // 'isPrototypeOf',
  10. // 'propertyIsEnumerable',
  11. // 'toString']

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

Object.defineProperty(),Object.defineProperties()

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

  1. Object.defineProperty(object, propertyName, attributesObject)

Object.defineProperty方法接受三个参数,依次如下。

  • object:属性所在的对象
  • propertyName:字符串,表示属性名
  • attributesObject:属性描述对象

举例来说,定义obj.p可以写成下面这样。

  1. var obj = Object.defineProperty({}, 'p', {
  2. value: 123,
  3. writable: false,
  4. enumerable: true,
  5. configurable: false
  6. });
  7. obj.p // 123
  8. obj.p = 246;
  9. obj.p // 123

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

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

如果一次性定义或修改多个属性,可以使用Object.defineProperties()方法。

  1. var obj = Object.defineProperties({}, {
  2. p1: { value: 123, enumerable: true },
  3. p2: { value: 'abc', enumerable: true },
  4. p3: { get: function () { return this.p1 + this.p2 },
  5. enumerable:true,
  6. configurable:true
  7. }
  8. });
  9. obj.p1 // 123
  10. obj.p2 // "abc"
  11. obj.p3 // "123abc"

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

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

  1. var obj = {};
  2. Object.defineProperty(obj, 'p', {
  3. value: 123,
  4. get: function() { return 456; }
  5. });
  6. // TypeError: Invalid property.
  7. // A property cannot both have accessors and be writable or have a value
  8. Object.defineProperty(obj, 'p', {
  9. writable: true,
  10. get: function() { return 456; }
  11. });
  12. // TypeError: Invalid property descriptor.
  13. // Cannot both specify accessors and a value or writable attribute

上面代码中,同时定义了get属性和value属性,以及将writable属性设为true,就会报错。

Object.defineProperty()Object.defineProperties()参数里面的属性描述对象,writableconfigurableenumerable这三个属性的默认值都为false

  1. var obj = {};
  2. Object.defineProperty(obj, 'foo', {});
  3. Object.getOwnPropertyDescriptor(obj, 'foo')
  4. // {
  5. // value: undefined,
  6. // writable: false,
  7. // enumerable: false,
  8. // configurable: false
  9. // }

上面代码中,定义obj.foo时用了一个空的属性描述对象,就可以看到各个元属性的默认值。

Object.prototype.propertyIsEnumerable()

实例对象的propertyIsEnumerable()方法返回一个布尔值,用来判断某个属性是否可遍历。注意,这个方法只能用于判断对象自身的属性,对于继承的属性一律返回false

  1. var obj = {};
  2. obj.p = 123;
  3. obj.propertyIsEnumerable('p') // true
  4. obj.propertyIsEnumerable('toString') // false

上面代码中,obj.p是可遍历的,而obj.toString是继承的属性。

元属性

属性描述对象的各个属性称为“元属性”,因为它们可以看作是控制属性的属性。

value

value属性是目标属性的值。

  1. var obj = {};
  2. obj.p = 123;
  3. Object.getOwnPropertyDescriptor(obj, 'p').value
  4. // 123
  5. Object.defineProperty(obj, 'p', { value: 246 });
  6. obj.p // 246

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

writable

writable属性是一个布尔值,决定了目标属性的值(value)是否可以被改变。

  1. var obj = {};
  2. Object.defineProperty(obj, 'a', {
  3. value: 37,
  4. writable: false
  5. });
  6. obj.a // 37
  7. obj.a = 25;
  8. obj.a // 37

上面代码中,obj.awritable属性是false。然后,改变obj.a的值,不会有任何效果。

注意,正常模式下,对writablefalse的属性赋值不会报错,只会默默失败。但是,严格模式下会报错,即使对a属性重新赋予一个同样的值。

  1. 'use strict';
  2. var obj = {};
  3. Object.defineProperty(obj, 'a', {
  4. value: 37,
  5. writable: false
  6. });
  7. obj.a = 37;
  8. // Uncaught TypeError: Cannot assign to read only property 'a' of object

上面代码是严格模式,对obj.a任何赋值行为都会报错。

如果原型对象的某个属性的writablefalse,那么子对象将无法自定义这个属性。

  1. var proto = Object.defineProperty({}, 'foo', {
  2. value: 'a',
  3. writable: false
  4. });
  5. var obj = Object.create(proto);
  6. obj.foo = 'b';
  7. obj.foo // 'a'

上面代码中,proto是原型对象,它的foo属性不可写。obj对象继承proto,也不可以再自定义这个属性了。如果是严格模式,这样做还会抛出一个错误。

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

  1. var proto = Object.defineProperty({}, 'foo', {
  2. value: 'a',
  3. writable: false
  4. });
  5. var obj = Object.create(proto);
  6. Object.defineProperty(obj, 'foo', {
  7. value: 'b'
  8. });
  9. obj.foo // "b"

enumerable

enumerable(可遍历性)返回一个布尔值,表示目标属性是否可遍历。

JavaScript 的早期版本,for...in循环是基于in运算符的。我们知道,in运算符不管某个属性是对象自身的还是继承的,都会返回true

  1. var obj = {};
  2. 'toString' in obj // true

上面代码中,toString不是obj对象自身的属性,但是in运算符也返回true,这导致了toString属性也会被for...in循环遍历。

这显然不太合理,后来就引入了“可遍历性”这个概念。只有可遍历的属性,才会被for...in循环遍历,同时还规定toString这一类实例对象继承的原生属性,都是不可遍历的,这样就保证了for...in循环的可用性。

具体来说,如果一个属性的enumerablefalse,下面三个操作不会取到该属性。

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

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

  1. var obj = {};
  2. Object.defineProperty(obj, 'x', {
  3. value: 123,
  4. enumerable: false
  5. });
  6. obj.x // 123
  7. for (var key in obj) {
  8. console.log(key);
  9. }
  10. // undefined
  11. Object.keys(obj) // []
  12. JSON.stringify(obj) // "{}"

上面代码中,obj.x属性的enumerablefalse,所以一般的遍历操作都无法获取该属性,使得它有点像“秘密”属性,但不是真正的私有属性,还是可以直接获取它的值。

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

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

configurable

configurable(可配置性)返回一个布尔值,决定了是否可以修改属性描述对象。也就是说,configurablefalse时,valuewritableenumerableconfigurable都不能被修改了。

  1. var obj = Object.defineProperty({}, 'p', {
  2. value: 1,
  3. writable: false,
  4. enumerable: false,
  5. configurable: false
  6. });
  7. Object.defineProperty(obj, 'p', {value: 2})
  8. // TypeError: Cannot redefine property: p
  9. Object.defineProperty(obj, 'p', {writable: true})
  10. // TypeError: Cannot redefine property: p
  11. Object.defineProperty(obj, 'p', {enumerable: true})
  12. // TypeError: Cannot redefine property: p
  13. Object.defineProperty(obj, 'p', {configurable: true})
  14. // TypeError: Cannot redefine property: p

上面代码中,obj.pconfigurablefalse。然后,改动valuewritableenumerableconfigurable,结果都报错。

注意,writable只有在false改为true会报错,true改为false是允许的。

  1. var obj = Object.defineProperty({}, 'p', {
  2. writable: true,
  3. configurable: false
  4. });
  5. Object.defineProperty(obj, 'p', {writable: false})
  6. // 修改成功

至于value,只要writableconfigurable有一个为true,就允许改动。

  1. var o1 = Object.defineProperty({}, 'p', {
  2. value: 1,
  3. writable: true,
  4. configurable: false
  5. });
  6. Object.defineProperty(o1, 'p', {value: 2})
  7. // 修改成功
  8. var o2 = Object.defineProperty({}, 'p', {
  9. value: 1,
  10. writable: false,
  11. configurable: true
  12. });
  13. Object.defineProperty(o2, 'p', {value: 2})
  14. // 修改成功

另外,writablefalse时,直接目标属性赋值,不报错,但不会成功。

  1. var obj = Object.defineProperty({}, 'p', {
  2. value: 1,
  3. writable: false,
  4. configurable: false
  5. });
  6. obj.p = 2;
  7. obj.p // 1

上面代码中,obj.pwritablefalse,对obj.p直接赋值不会生效。如果是严格模式,还会报错。

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

  1. var obj = Object.defineProperties({}, {
  2. p1: { value: 1, configurable: true },
  3. p2: { value: 2, configurable: false }
  4. });
  5. delete obj.p1 // true
  6. delete obj.p2 // false
  7. obj.p1 // undefined
  8. obj.p2 // 2

上面代码中,obj.p1configurabletrue,所以可以被删除,obj.p2就无法删除。

存取器

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

一旦对目标属性定义了存取器,那么存取的时候,都将执行对应的函数。利用这个功能,可以实现许多高级特性,比如某个属性禁止赋值。

  1. var obj = Object.defineProperty({}, 'p', {
  2. get: function () {
  3. return 'getter';
  4. },
  5. set: function (value) {
  6. console.log('setter: ' + value);
  7. }
  8. });
  9. obj.p // "getter"
  10. obj.p = 123 // "setter: 123"

上面代码中,obj.p定义了getset属性。obj.p取值时,就会调用get;赋值时,就会调用set

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

  1. var obj = {
  2. get p() {
  3. return 'getter';
  4. },
  5. set p(value) {
  6. console.log('setter: ' + value);
  7. }
  8. };

上面的写法与定义属性描述对象是等价的,而且使用更广泛。

注意,取值函数get不能接受参数,存值函数set只能接受一个参数(即属性的值)。

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

  1. var obj ={
  2. $n : 5,
  3. get next() { return this.$n++ },
  4. set next(n) {
  5. if (n >= this.$n) this.$n = n;
  6. else throw new Error('新的值必须大于当前值');
  7. }
  8. };
  9. obj.next // 5
  10. obj.next = 10;
  11. obj.next // 10
  12. obj.next = 5;
  13. // Uncaught Error: 新的值必须大于当前值

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

对象的拷贝

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

  1. var extend = function (to, from) {
  2. for (var property in from) {
  3. to[property] = from[property];
  4. }
  5. return to;
  6. }
  7. extend({}, {
  8. a: 1
  9. })
  10. // {a: 1}

上面这个方法的问题在于,如果遇到存取器定义的属性,会只拷贝值。

  1. extend({}, {
  2. get a() { return 1 }
  3. })
  4. // {a: 1}

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

  1. var extend = function (to, from) {
  2. for (var property in from) {
  3. if (!from.hasOwnProperty(property)) continue;
  4. Object.defineProperty(
  5. to,
  6. property,
  7. Object.getOwnPropertyDescriptor(from, property)
  8. );
  9. }
  10. return to;
  11. }
  12. extend({}, { get a(){ return 1 } })
  13. // { get a(){ return 1 } })

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

控制对象状态

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

Object.preventExtensions()

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

  1. var obj = new Object();
  2. Object.preventExtensions(obj);
  3. Object.defineProperty(obj, 'p', {
  4. value: 'hello'
  5. });
  6. // TypeError: Cannot define property:p, object is not extensible.
  7. obj.p = 1;
  8. obj.p // undefined

上面代码中,obj对象经过Object.preventExtensions以后,就无法添加新属性了。

Object.isExtensible()

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

  1. var obj = new Object();
  2. Object.isExtensible(obj) // true
  3. Object.preventExtensions(obj);
  4. Object.isExtensible(obj) // false

上面代码中,对obj对象使用Object.preventExtensions方法以后,再使用Object.isExtensible方法,返回false,表示已经不能添加新属性了。

Object.seal()

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

  1. var obj = { p: 'hello' };
  2. Object.seal(obj);
  3. delete obj.p;
  4. obj.p // "hello"
  5. obj.x = 'world';
  6. obj.x // undefined

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

Object.seal实质是把属性描述对象的configurable属性设为false,因此属性描述对象不再能改变了。

  1. var obj = {
  2. p: 'a'
  3. };
  4. // seal方法之前
  5. Object.getOwnPropertyDescriptor(obj, 'p')
  6. // Object {
  7. // value: "a",
  8. // writable: true,
  9. // enumerable: true,
  10. // configurable: true
  11. // }
  12. Object.seal(obj);
  13. // seal方法之后
  14. Object.getOwnPropertyDescriptor(obj, 'p')
  15. // Object {
  16. // value: "a",
  17. // writable: true,
  18. // enumerable: true,
  19. // configurable: false
  20. // }
  21. Object.defineProperty(o, 'p', {
  22. enumerable: false
  23. })
  24. // TypeError: Cannot redefine property: p

上面代码中,使用Object.seal方法之后,属性描述对象的configurable属性就变成了false,然后改变enumerable属性就会报错。

Object.seal只是禁止新增或删除属性,并不影响修改某个属性的值。

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

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

Object.isSealed()

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

  1. var obj = { p: 'a' };
  2. Object.seal(obj);
  3. Object.isSealed(obj) // true

这时,Object.isExtensible方法也返回false

  1. var obj = { p: 'a' };
  2. Object.seal(obj);
  3. Object.isExtensible(obj) // false

Object.freeze()

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

  1. var obj = {
  2. p: 'hello'
  3. };
  4. Object.freeze(obj);
  5. obj.p = 'world';
  6. obj.p // "hello"
  7. obj.t = 'hello';
  8. obj.t // undefined
  9. delete obj.p // false
  10. obj.p // "hello"

上面代码中,对obj对象进行Object.freeze()以后,修改属性、新增属性、删除属性都无效了。这些操作并不报错,只是默默地失败。如果在严格模式下,则会报错。

Object.isFrozen()

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

  1. var obj = {
  2. p: 'hello'
  3. };
  4. Object.freeze(obj);
  5. Object.isFrozen(obj) // true

使用Object.freeze方法以后,Object.isSealed将会返回trueObject.isExtensible返回false

  1. var obj = {
  2. p: 'hello'
  3. };
  4. Object.freeze(obj);
  5. Object.isSealed(obj) // true
  6. Object.isExtensible(obj) // false

Object.isFrozen的一个用途是,确认某个对象没有被冻结后,再对它的属性赋值。

  1. var obj = {
  2. p: 'hello'
  3. };
  4. Object.freeze(obj);
  5. if (!Object.isFrozen(obj)) {
  6. obj.p = 'world';
  7. }

上面代码中,确认obj没有被冻结后,再对它的属性赋值,就不会报错了。

局限性

上面的三个方法锁定对象的可写性有一个漏洞:可以通过改变原型对象,来为对象增加属性。

  1. var obj = new Object();
  2. Object.preventExtensions(obj);
  3. var proto = Object.getPrototypeOf(obj);
  4. proto.t = 'hello';
  5. obj.t
  6. // hello

上面代码中,对象obj本身不能新增属性,但是可以在它的原型对象上新增属性,就依然能够在obj上读到。

一种解决方案是,把obj的原型也冻结住。

  1. var obj = new Object();
  2. Object.preventExtensions(obj);
  3. var proto = Object.getPrototypeOf(obj);
  4. Object.preventExtensions(proto);
  5. proto.t = 'hello';
  6. obj.t // undefined

另外一个局限是,如果属性值是对象,上面这些方法只能冻结属性指向的对象,而不能冻结对象本身的内容。

  1. var obj = {
  2. foo: 1,
  3. bar: ['a', 'b']
  4. };
  5. Object.freeze(obj);
  6. obj.bar.push('c');
  7. obj.bar // ["a", "b", "c"]

上面代码中,obj.bar属性指向一个数组,obj对象被冻结以后,这个指向无法改变,即无法指向其他值,但是所指向的数组是可以改变的。


本文转载自 GitHub 开源项目 wangdoc / javascript-tutorial ,用于个人学习,无任何商业用途,该开源项目由阮一峰发起,在此感谢阮一峰老师的无私奉献。如本文有任何变更或修改,也会积极提交到开源项目做贡献。

(完)