亲宝软件园·资讯

展开

你必须了解的JavaScript中的属性描述对象详解(下)

程序小猿2 人气:0

元属性

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.awritable属性是false。然后,改变obj.a的值,不会有任何效果。

注意,正常模式下,对writablefalse的属性赋值不会报错,只会默默失败。但是,严格模式下会报错,即使对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任何赋值行为都会报错。

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

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 = {};
'totring' in obj //true

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

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

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

因此,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属性的enumerablefalse,所以一般的遍历操作都无法获取该属性,使得它有点像“秘密”属性,但不是真正的私有属性,还是可以直接获取它的值。

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

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

configurable

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

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.definetyProperty(obj,'p',{enumerable:true})
//TypeError:Cannot redefine property:p

Object.defineProperty(obj,'p',{configurable:true})
//TypeError:Cannot redefine property:p

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

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

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

Object.defineProperty(obj,'p',{writable:false})
//修改成功

至于value,只要writableconfigurable有一个为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})
//修改成功

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

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

obj.p = 2;
obj.p //1

上面代码中,obj.pwritablefalse,对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.p1configurabletrue,所以可以被删除,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定义了getset属性。obj.p取值时,就会调用get;赋值时,就会调用set

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

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

上面两种写法,虽然属性p的读取和赋值行为是一样的,但是有一些细微的区别。第一种写法,属性pconfigurableenumerable都为false,从而导致属性p是不可遍历的;第二种写法,属性pconfigurableenumerable都为true,因此属性p是可遍历的。实际开发中,写法二更常用。

注意,取值函数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将会返回trueObject.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.preventEctensions(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对象被冻结以后,这个指向无法改变,即无法指向其他值,但是所指向的数组是可以改变的。

加载全部内容

相关教程
猜你喜欢
用户评论