Object.defineProperty()函数之属性描述对象
目录
- 概述
- Object.getOwnPropertyDescriptor()
- Object.getOwnPropertyNames()
- Object.defineProperty(),Object.defineProperties()
- Object.prototype.propertyIsEnumerable()
- 元属性
- value
- writable
- enumerable
- configurable
- 存取器
- 对象的拷贝
- 控制对象状态
- Object.preventExtensions()
- Object.isExtensible()
- Object.seal()
- Object.isSealed()
- Object.freeze()
- Object.isFrozen()
- 局限性
概述
JavaScript 提供了一个内部数据结构,用来描述对象的属性,控制它的行为,比如该属性是否可写、可遍历等等。这个内部数据结构称为“属性描述对象”(attributes object)。每个属性都有自己对应的属性描述对象,保存该属性的一些元信息。
下面是属性描述对象的一个例子:
{ value: 123, writable: false, enumerable: true, configurable: false, get: undefined, set: undefined }
属性描述对象提供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
方法可以获取属性描述对象。它的第一个参数是一个对象,第二个参数是一个字符串,对应该对象的某个属性名。
var obj = { p: 'a' }; Object.getOwnPropertyDescriptor(obj, 'p') // Object { value: "a", // writable: true, // enumerable: true, // configurable: true // }
上面代码中,Object.getOwnPropertyDescriptor
方法获取obj.p
的属性描述对象。
注意:Object.getOwnPropertyDescriptor
方法只能用于对象自身的属性,不能用于继承的属性。
var obj = { p: 'a' }; Object.getOwnPropertyDescriptor(obj, 'toString') // undefined
上面代码中,toString
是Obj
对象继承的属性,Object.getOwnPropertyDescriptor
无法获取。
Object.getOwnPropertyNames()
Object.getOwnPropertyNames
方法返回一个数组,成员是参数对象自身的全部属性的属性名,不管该属性是否可遍历。
var obj = Object.defineProperties({}, { p1: { value: 1, enumerable: true }, p2: { value: 2, enumerable: false } }); Object.getOwnPropertyNames(obj) // ["p1", "p2"]
上面代码中,obj.p1
是可遍历的,obj.p2
是不可遍历的。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
方法接受三个参数,
依次如下:
- 属性所在的对象
- 属性名(它应该是一个字符串)
- 属性描述对象
举例来说,定义obj.p
可以写成下面这样。
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.p
属性。由于属性描述对象的writable
属性为false
,所以obj.p
属性不可写。注意,这里的Object.defineProperty
方法的第一个参数是{}
(一个新建的空对象),p
属性直接定义在这个空对象上面,然后返回这个对象,这是Object.defineProperty
的常见写法。
如果属性已经存在,Object.defineProperty
方法相当于更新该属性的属性描述对象。
如果一次性定义或修改多个属性,可以使用Object.defineProperties
方法。
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
上面代码中,同时定义了get
属性和value
属性,以及将writable
属性设为true
,就会报错。
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()
实例对象的propertyIsEnumerable
方法返回一个布尔值,用来判断某个属性是否可遍历。
var obj = {}; obj.p = 123; obj.propertyIsEnumerable('p') // true obj.propertyIsEnumerable('toString') // false
上面代码中,obj.p
是可遍历的,而继承自原型对象的obj.toString
属性是不可遍历的。
元属性
属性描述对象的各个属性称为“元属性”,因为它们可以看作是控制属性的属性。
value
value
属性是目标属性的值。
var obj = {}; obj.p = 123; Object.getOwnPropertyDescriptor(obj, 'p').value // 123 Object.defineProperty(obj, 'p', { value: 246 }); obj.p // 246
上面代码是通过value
属性,读取或改写obj.p
的例子。
writable
writable
属性是一个布尔值,决定了目标属性的值(value)是否可以被改变。
var obj = {}; Object.defineProperty(obj, 'a', { value: 37, writable: false }); obj.a // 37 obj.a = 25; obj.a // 37
上面代码中,obj.a
的writable
属性是false
。然后,改变obj.a
的值,不会有任何效果。
注意:正常模式下,对writable
为false
的属性赋值不会报错,只会默默失败。但是,严格模式下会报错,即使对a
属性重新赋予一个同样的值。
'use strict'; var obj = {}; Object.defineProperty(obj, 'a', { value: 37, writable: false }); obj.a = 37; // Uncaught TypeError: Cannot assign to read only property 'a' of object
上面代码是严格模式,对obj.a
任何赋值行为都会报错。
如果原型对象的某个属性的writable
为false
,那么子对象将无法自定义这个属性。
var proto = Object.defineProperty({}, 'foo', { value: 'a', writable: false }); var obj = Object.create(proto); obj.foo = 'b'; obj.foo // 'a'
上面代码中,proto
是原型对象,它的foo
属性不可写。obj
对象继承proto
,也不可以再自定义这个属性了。如果是严格模式,这样做还会抛出一个错误。
但是,有一个规避方法,就是通过覆盖属性描述对象,绕过这个限制。原因是这种情况下,原型链会被完全忽视。
var proto = Object.defineProperty({}, 'foo', { value: 'a', writable: false }); var obj = Object.create(proto); Object.defineProperty(obj, 'foo', { value: 'b' }); obj.foo // "b"
enumerable
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
都不能被修改了。
var obj = Object.defineProperty({}, 'p', { value: 1, writable: false, enumerable: false, configurable: false }); Object.defineProperty(obj, 'p', {value: 2}) // TypeError: Cannot redefine property: p Object.defineProperty(obj, 'p', {writable: true}) // TypeError: Cannot redefine property: p Object.defineProperty(obj, 'p', {enumerable: true}) // TypeError: Cannot redefine property: p Object.defineProperty(obj, 'p', {configurable: true}) // TypeError: Cannot redefine property: p
上面代码中,obj.p
的configurable
为false
。然后,改动value
、writable
、enumerable
、configurable
,结果都报错。
注意:writable
只有在false
改为true
会报错,true
改为false
是允许的。
var obj = Object.defineProperty({}, 'p', { writable: true, configurable: false }); Object.defineProperty(obj, 'p', {writable: false}) // 修改成功
至于value
,只要writable
和configurable
有一个为true
,就允许改动。
var o1 = Object.defineProperty({}, 'p', { value: 1, writable: true, configurable: false }); Object.defineProperty(o1, 'p', {value: 2}) // 修改成功 var o2 = Object.defineProperty({}, 'p', { value: 1, writable: false, configurable: true }); Object.defineProperty(o2, 'p', {value: 2}) // 修改成功
另外,configurable
为false
时,直接目标属性赋值,不报错,但不会成功。
var obj = Object.defineProperty({}, 'p', { value: 1, configurable: false }); obj.p = 2; obj.p // 1
上面代码中,obj.p
的configurable
为false
,对obj.p
赋值是不会生效的。如果是严格模式,还会报错。
可配置性决定了目标属性是否可以被删除(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
就无法删除。
存取器
除了直接定义以外,属性还可以用存取器(accessor)定义。其中,存值函数称为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 (to, from) { for (var property in from) { to[property] = from[property]; } return to; } 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
读不到继承属性的属性描述对象。
控制对象状态
有时需要冻结对象的读写状态,防止对象被改变。JavaScript 提供了三种冻结方法,最弱的一种是Object.preventExtensions
,其次是Object.seal
,最强的是Object.freeze
。
Object.preventExtensions()
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
上面代码中,obj
对象经过Object.preventExtensions
以后,就无法添加新属性了。
Object.isExtensible()
Object.isExtensible
方法用于检查一个对象是否使用了Object.preventExtensions
方法。也就是说,检查是否可以为一个对象添加属性。
var obj = new Object(); Object.isExtensible(obj) // true Object.preventExtensions(obj); Object.isExtensible(obj) // false
上面代码中,对obj
对象使用Object.preventExtensions
方法以后,再使用Object.isExtensible
方法,返回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
方法以后,就无法添加新属性和删除旧属性了。
Object.seal
实质是把属性描述对象的configurable
属性设为false
,因此属性描述对象不再能改变了。
var obj = { p: 'a' }; // seal方法之前 Object.getOwnPropertyDescriptor(obj, 'p') // Object { // value: "a", // writable: true, // enumerable: true, // configurable: true // } Object.seal(obj); // seal方法之后 Object.getOwnPropertyDescriptor(obj, 'p') // Object { // value: "a", // writable: true, // enumerable: true, // configurable: false // } Object.defineProperty(o, 'p', { enumerable: false }) // TypeError: Cannot redefine property: p
上面代码中,使用Object.seal
方法之后,属性描述对象的configurable
属性就变成了false
,然后改变enumerable
属性就会报错。
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.isExtensible
方法也返回false
。
var obj = { p: 'a' }; Object.seal(obj); Object.isExtensible(obj) // false
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"
上面代码中,对obj
对象进行Object.freeze()
以后,修改属性、新增属性、删除属性都无效了。这些操作并不报错,只是默默地失败。如果在严格模式下,则会报错。
Object.isFrozen()
Object.isFrozen
方法用于检查一个对象是否使用了Object.freeze
方法。
var obj = { p: 'hello' }; Object.freeze(obj); Object.isFrozen(obj) // true
使用Object.freeze
方法以后,Object.isSealed
将会返回true
,Object.isExtensible
返回false
。
var obj = { p: 'hello' }; Object.freeze(obj); Object.isSealed(obj) // true Object.isExtensible(obj) // false
Object.isFrozen
的一个用途是,确认某个对象没有被冻结后,再对它的属性赋值。
var obj = { p: 'hello' }; Object.freeze(obj); if (!Object.isFrozen(obj)) { obj.p = 'world'; }
上面代码中,确认obj
没有被冻结后,再对它的属性赋值,就不会报错了。
局限性
上面的三个方法锁定对象的可写性有一个漏洞:可以通过改变原型对象,来为对象增加属性。
var obj = new Object(); Object.preventExtensions(obj); var proto = Object.getPrototypeOf(obj); proto.t = 'hello'; obj.t // hello
上面代码中,对象obj
本身不能新增属性,但是可以在它的原型对象上新增属性,就依然能够在obj
上读到。
一种解决方案是,把obj
的原型也冻结住。
var obj = new Object(); Object.preventExtensions(obj); var proto = Object.getPrototypeOf(obj); Object.preventExtensions(proto); proto.t = 'hello'; obj.t // undefined
另外一个局限是,如果属性值是对象,上面这些方法只能冻结属性指向的对象,而不能冻结对象本身的内容。
var obj = { foo: 1, bar: ['a', 'b'] }; Object.freeze(obj); obj.bar.push('c'); obj.bar // ["a", "b", "c"]
上面代码中,obj.bar
属性指向一个数组,obj
对象被冻结以后,这个指向无法改变,即无法指向其他值,但是所指向的数组是可以改变的。
到此这篇关于Object.defineProperty()函数之属性描述对象的文章就介绍到这了,更多相关Object.defineProperty函数内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!