JavaScript的标准库
Object 对象
概述
JavaScript 的所有其他对象都继承自Object
对象,即那些对象都是Object
的实例。
Object
对象的原生方法分成两类:Object
本身的方法与Object
的实例方法。
(1)Object
对象本身的方法
所谓“本身的方法”就是直接定义在Object
对象的方法。
Object.print = function (o) { console.log(o) };
上面代码中,print
方法就是直接定义在Object
对象上。
(2)Object
的实例方法
所谓实例方法就是定义在Object
原型对象Object.prototype
上的方法。它可以被Object
实例直接使用。
Object.prototype.print = function () {
console.log(this);
};
var obj = new Object();
obj.print() // Object
上面代码中,Object.prototype
定义了一个print
方法,然后生成一个Object
的实例obj
。obj
直接继承了Object.prototype
的属性和方法,可以直接使用obj.print
调用print
方法。也就是说,obj
对象的print
方法实质上就是调用Object.prototype.print
方法。
凡是定义在Object.prototype
对象上面的属性和方法,将被所有实例对象共享就可以了。
以下先介绍Object
作为函数的用法,然后再介绍Object
对象的原生方法,分成对象自身的方法(又称为“静态方法”)和实例方法两部分。
Object()
Object
本身是一个函数,可以当作工具方法使用,将任意值转为对象。这个方法常用于保证某个值一定是对象。
如果参数为空(或者为undefined
和null
),Object()
返回一个空对象。
var obj = Object();
// 等同于
var obj = Object(undefined);
var obj = Object(null);
obj instanceof Object // true
上面代码的含义,是将undefined
和null
转为对象,结果得到了一个空对象obj
。
instanceof
运算符用来验证,一个对象是否为指定的构造函数的实例。obj instanceof Object
返回true
,就表示obj
对象是Object
的实例。
如果参数是原始类型的值,Object
方法将其转为对应的包装对象的实例。
var obj = Object(1);
obj instanceof Object // true
obj instanceof Number // true
var obj = Object('foo');
obj instanceof Object // true
obj instanceof String // true
var obj = Object(true);
obj instanceof Object // true
obj instanceof Boolean // true
上面代码中,Object
函数的参数是各种原始类型的值,转换成对象就是原始类型值对应的包装对象。
如果Object
方法的参数是一个对象,它总是返回该对象,即不用转换。
var arr = [];
var obj = Object(arr); // 返回原数组
obj === arr // true
var value = {};
var obj = Object(value) // 返回原对象
obj === value // true
var fn = function () {};
var obj = Object(fn); // 返回原函数
obj === fn // true
利用这一点,可以写一个判断变量是否为对象的函数。
function isObject(value) {
return value === Object(value);
}
isObject([]) // true
isObject(true) // false
Object 构造函数
Object
不仅可以当作工具函数使用,还可以当作构造函数使用,即前面可以使用new
命令。
Object
构造函数的首要用途,是直接通过它来生成新对象。
var obj = new Object();
注意,通过
var obj = new Object()
的写法生成新对象,与字面量的写法var obj = {}
是等价的。或者说,后者只是前者的一种简便写法。
Object
构造函数的用法与工具方法很相似,几乎一模一样。使用时,可以接受一个参数,如果该参数是一个对象,则直接返回这个对象;如果是一个原始类型的值,则返回该值对应的包装对象。
var o1 = {a: 1};
var o2 = new Object(o1);
o1 === o2 // true
var obj = new Object(123);
obj instanceof Number // true
虽然用法相似,但是Object(value)
与new Object(value)
两者的语义是不同的,Object(value)
表示将value
转成一个对象,new Object(value)
则表示新生成一个对象,它的值是value
。
Object 的静态方法
所谓“静态方法”,是指部署在Object
对象自身的方法。
Object.keys(),Object.getOwnPropertyNames()
Object.keys
方法和Object.getOwnPropertyNames
方法都用来遍历对象的属性。
Object.keys
方法的参数是一个对象,返回一个数组。该数组的成员都是该对象自身的(而不是继承的)所有属性名。
var obj = {
p1: 123,
p2: 456
};
Object.keys(obj) // ["p1", "p2"]
Object.getOwnPropertyNames
方法与Object.keys
类似,也是接受一个对象作为参数,返回一个数组,包含了该对象自身的所有属性名。
var obj = {
p1: 123,
p2: 456
};
Object.getOwnPropertyNames(obj) // ["p1", "p2"]
对于一般的对象来说,Object.keys()
和Object.getOwnPropertyNames()
返回的结果是一样的。只有涉及不可枚举属性时,才会有不一样的结果。Object.keys
方法只返回可枚举的属性,Object.getOwnPropertyNames
方法还返回不可枚举的属性名。
var a = ['Hello', 'World'];
Object.keys(a) // ["0", "1"]
Object.getOwnPropertyNames(a) // ["0", "1", "length"]
上面代码中,数组的length
属性是不可枚举的属性,所以只出现在Object.getOwnPropertyNames
方法的返回结果中。
由于 JavaScript 没有提供计算对象属性个数的方法,所以可以用这两个方法代替。
var obj = {
p1: 123,
p2: 456
};
Object.keys(obj).length // 2
Object.getOwnPropertyNames(obj).length // 2
一般情况下,几乎总是使用Object.keys
方法,遍历对象的属性。
除了上面提到的两个方法,Object
还有不少其他静态方法,将在后文逐一详细介绍。
(1)对象属性模型的相关方法
Object.getOwnPropertyDescriptor()
:获取某个属性的描述对象。Object.defineProperty()
:通过描述对象,定义某个属性。Object.defineProperties()
:通过描述对象,定义多个属性。
(2)控制对象状态的方法
Object.preventExtensions()
:防止对象扩展。Object.isExtensible()
:判断对象是否可扩展。Object.seal()
:禁止对象配置。Object.isSealed()
:判断一个对象是否可配置。Object.freeze()
:冻结一个对象。Object.isFrozen()
:判断一个对象是否被冻结。
(3)原型链相关方法
Object.create()
:该方法可以指定原型对象和属性,返回一个新的对象。Object.getPrototypeOf()
:获取对象的Prototype
对象。
Object 的实例方法
除了静态方法,还有不少方法定义在Object.prototype
对象。它们称为实例方法,所有Object
的实例对象都继承了这些方法。
Object
实例对象的方法,主要有以下六个。
Object.prototype.valueOf()
:返回当前对象对应的值。Object.prototype.toString()
:返回当前对象对应的字符串形式。Object.prototype.toLocaleString()
:返回当前对象对应的本地字符串形式。Object.prototype.hasOwnProperty()
:判断某个属性是否为当前对象自身的属性,还是继承自原型对象的属性。Object.prototype.isPrototypeOf()
:判断当前对象是否为另一个对象的原型。Object.prototype.propertyIsEnumerable()
:判断某个属性是否可枚举。
先介绍前四个方法,另外两个方法将在后文介绍。
Object.prototype.valueOf()
valueOf
方法的作用是返回一个对象的“值”,默认情况下返回对象本身。
var obj = new Object();
obj.valueOf() === obj // true
上面代码比较obj.valueOf()
与obj
本身,两者是一样的。
valueOf
方法的主要用途是,JavaScript 自动类型转换时会默认调用这个方法。
var obj = new Object();
1 + obj // "1[object Object]"
上面代码将对象obj
与数字1
相加,这时 JavaScript 就会默认调用valueOf()
方法,求出obj
的值再与1
相加。所以,如果自定义valueOf
方法,就可以得到想要的结果。
var obj = new Object();
obj.valueOf = function () {
return 2;
};
1 + obj // 3
上面代码自定义了obj
对象的valueOf
方法,于是1 + obj
就得到了3
。这种方法就相当于用自定义的obj.valueOf
,覆盖Object.prototype.valueOf
。
Object.prototype.toString()
toString
方法的作用是返回一个对象的字符串形式,默认情况下返回类型字符串。
var o1 = new Object();
o1.toString() // "[object Object]"
var o2 = {a:1};
o2.toString() // "[object Object]"
上面代码表示,对于一个对象调用toString
方法,会返回字符串[object Object]
,该字符串说明对象的类型。
字符串[object Object]
本身没有太大的用处,但是通过自定义toString
方法,可以让对象在自动类型转换时,得到想要的字符串形式。
var obj = new Object();
obj.toString = function () {
return 'hello';
};
obj + ' ' + 'world' // "hello world"
上面代码表示,当对象用于字符串加法时,会自动调用toString
方法。由于自定义了toString
方法,所以返回字符串hello world
。
数组、字符串、函数、Date 对象都分别部署了自定义的toString
方法,覆盖了Object.prototype.toString
方法。
[1, 2, 3].toString() // "1,2,3"
'123'.toString() // "123"
(function () {
return 123;
}).toString()
// "function () {
// return 123;
// }"
(new Date()).toString()
// "Tue May 10 2016 09:11:31 GMT+0800 (CST)"
上面代码中,数组、字符串、函数、Date 对象调用toString
方法,并不会返回[object Object]
,因为它们都自定义了toString
方法,覆盖原始方法。
toString() 的应用:判断数据类型
Object.prototype.toString
方法返回对象的类型字符串,因此可以用来判断一个值的类型。
var obj = {};
obj.toString() // "[object Object]"
上面代码调用空对象的toString
方法,结果返回一个字符串object Object
,其中第二个Object
表示该值的构造函数。这是一个十分有用的判断数据类型的方法。
由于实例对象可能会自定义toString
方法,覆盖掉Object.prototype.toString
方法,所以为了得到类型字符串,最好直接使用Object.prototype.toString
方法。通过函数的call
方法,可以在任意值上调用这个方法,帮助我们判断这个值的类型。
Object.prototype.toString.call(value)
上面代码表示对value
这个值调用Object.prototype.toString
方法。
不同数据类型的Object.prototype.toString
方法返回值如下。
- 数值:返回
[object Number]
。 - 字符串:返回
[object String]
。 - 布尔值:返回
[object Boolean]
。 - undefined:返回
[object Undefined]
。 - null:返回
[object Null]
。 - 数组:返回
[object Array]
。 - arguments 对象:返回
[object Arguments]
。 - 函数:返回
[object Function]
。 - Error 对象:返回
[object Error]
。 - Date 对象:返回
[object Date]
。 - RegExp 对象:返回
[object RegExp]
。 - 其他对象:返回
[object Object]
。
这就是说,Object.prototype.toString
可以看出一个值到底是什么类型。
Object.prototype.toString.call(2) // "[object Number]"
Object.prototype.toString.call('') // "[object String]"
Object.prototype.toString.call(true) // "[object Boolean]"
Object.prototype.toString.call(undefined) // "[object Undefined]"
Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call(Math) // "[object Math]"
Object.prototype.toString.call({}) // "[object Object]"
Object.prototype.toString.call([]) // "[object Array]"
利用这个特性,可以写出一个比typeof
运算符更准确的类型判断函数。
var type = function (o){
var s = Object.prototype.toString.call(o);
return s.match(/\[object (.*?)\]/)[1].toLowerCase();
};
type({}); // "object"
type([]); // "array"
type(5); // "number"
type(null); // "null"
type(); // "undefined"
type(/abcd/); // "regex"
type(new Date()); // "date"
在上面这个type
函数的基础上,还可以加上专门判断某种类型数据的方法。
var type = function (o){
var s = Object.prototype.toString.call(o);
return s.match(/\[object (.*?)\]/)[1].toLowerCase();
};
['Null',
'Undefined',
'Object',
'Array',
'String',
'Number',
'Boolean',
'Function',
'RegExp'
].forEach(function (t) {
type['is' + t] = function (o) {
return type(o) === t.toLowerCase();
};
});
type.isObject({}) // true
type.isNumber(NaN) // true
type.isRegExp(/abc/) // true
Object.prototype.toLocaleString()
Object.prototype.toLocaleString
方法与toString
的返回结果相同,也是返回一个值的字符串形式。
var obj = {};
obj.toString(obj) // "[object Object]"
obj.toLocaleString(obj) // "[object Object]"
这个方法的主要作用是留出一个接口,让各种不同的对象实现自己版本的toLocaleString
,用来返回针对某些地域的特定的值。
var person = {
toString: function () {
return 'Henry Norman Bethune';
},
toLocaleString: function () {
return '白求恩';
}
};
person.toString() // Henry Norman Bethune
person.toLocaleString() // 白求恩
上面代码中,toString()
方法返回对象的一般字符串形式,toLocaleString()
方法返回本地的字符串形式。
目前,主要有三个对象自定义了toLocaleString
方法。
- Array.prototype.toLocaleString()
- Number.prototype.toLocaleString()
- Date.prototype.toLocaleString()
举例来说,日期的实例对象的toString
和toLocaleString
返回值就不一样,而且toLocaleString
的返回值跟用户设定的所在地域相关。
var date = new Date();
date.toString() // "Tue Jan 01 2018 12:01:33 GMT+0800 (CST)"
date.toLocaleString() // "1/01/2018, 12:01:33 PM"
Object.prototype.hasOwnProperty()
Object.prototype.hasOwnProperty
方法接受一个字符串作为参数,返回一个布尔值,表示该实例对象自身是否具有该属性。
var obj = {
p: 123
};
obj.hasOwnProperty('p') // true
obj.hasOwnProperty('toString') // false
上面代码中,对象obj
自身具有p
属性,所以返回true
。toString
属性是继承的,所以返回false
。
总结:
- JavaScript 的所有其他对象都继承自
Object
对象,即那些对象都是Object
的实例。 Object
对象的原生方法分成两类:Object
本身的方法与Object
的实例方法。所谓“本身的方法”就是直接定义在Object
对象的方法。所谓实例方法就是定义在Object
原型对象Object.prototype
上的方法。Object
本身是一个函数,可以当作工具方法使用,将任意值转为对象。这个方法常用于保证某个值一定是对象。- 如果参数为空(或者为
undefined
和null
),Object()
返回一个空对象。 - 如果参数是原始类型的值,
Object
方法将其转为对应的包装对象的实例 - 如果
Object
方法的参数是一个对象,它总是返回该对象,即不用转换。 Object
不仅可以当作工具函数使用,还可以当作构造函数使用,即前面可以使用new
命令。Object
构造函数的首要用途,是直接通过它来生成新对象。Object
构造函数的用法与工具方法很相似,几乎一模一样。使用时,可以接受一个参数,如果该参数是一个对象,则直接返回这个对象;如果是一个原始类型的值,则返回该值对应的包装对象。- 虽然用法相似,但是
Object(value)
与new Object(value)
两者的语义是不同的,Object(value)
表示将value
转成一个对象,new Object(value)
则表示新生成一个对象,它的值是value
。 - 所谓“静态方法”,是指部署在
Object
对象自身的方法。 Object.keys
方法和Object.getOwnPropertyNames
方法都用来遍历对象的属性。Object.keys
方法的参数是一个对象,返回一个数组。该数组的成员都是该对象自身的(而不是继承的)所有属性名。Object.getOwnPropertyNames
方法与Object.keys
类似,也是接受一个对象作为参数,返回一个数组,包含了该对象自身的所有属性名。- 对于一般的对象来说,
Object.keys()
和Object.getOwnPropertyNames()
返回的结果是一样的。只有涉及不可枚举属性时,才会有不一样的结果。Object.keys
方法只返回可枚举的属性,Object.getOwnPropertyNames
方法还返回不可枚举的属性名。 valueOf
方法的作用是返回一个对象的“值”,默认情况下返回对象本身。toString
方法的作用是返回一个对象的字符串形式,默认情况下返回类型字符串。Object.prototype.toLocaleString
方法与toString
的返回结果相同,也是返回一个值的字符串形式。这个方法的主要作用是留出一个接口,让各种不同的对象实现自己版本的toLocaleString
,用来返回针对某些地域的特定的值。Object.prototype.hasOwnProperty
方法接受一个字符串作为参数,返回一个布尔值,表示该实例对象自身是否具有该属性。
属性描述对象
概述
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
方法接受三个参数,依次如下。
- object:属性所在的对象
- propertyName:字符串,表示属性名
- attributesObject:属性描述对象
举例来说,定义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.foo
时用了一个空的属性描述对象,就可以看到各个元属性的默认值。
Object.prototype.propertyIsEnumerable()
实例对象的propertyIsEnumerable()
方法返回一个布尔值,用来判断某个属性是否可遍历。注意,这个方法只能用于判断对象自身的属性,对于继承的属性一律返回false
。
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})
// 修改成功
另外,writable
为false
时,直接目标属性赋值,不报错,但不会成功。
var obj = Object.defineProperty({}, 'p', {
value: 1,
writable: false,
configurable: false
});
obj.p = 2;
obj.p // 1
上面代码中,obj.p
的writable
为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);
}
};
上面两种写法,虽然属性p
的读取和赋值行为是一样的,但是有一些细微的区别。第一种写法,属性p
的configurable
和enumerable
都为false
,从而导致属性p
是不可遍历的;第二种写法,属性p
的configurable
和enumerable
都为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(obj, '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
对象被冻结以后,这个指向无法改变,即无法指向其他值,但是所指向的数组是可以改变的。
总结:
-
JavaScript 提供了一个内部数据结构,用来描述对象的属性,控制它的行为,这个内部数据结构称为“属性描述对象”(attributes object)。每个属性都有自己对应的属性描述对象,保存该属性的一些元信息。
-
属性描述对象提供6个元属性:
value
是该属性的属性值,默认为undefined
;- writable
是一个布尔值,表示属性值(value)是否可改变(即是否可写),默认为
true; enumerable
是一个布尔值,表示该属性是否可遍历,默认为true
。如果设为false
,会使得某些操作(比如for...in
循环、Object.keys()
)跳过该属性;configurable
是一个布尔值,表示可配置性,默认为true
。如果设为false
,将阻止某些操作改写该属性,比如无法删除该属性,也不得改变该属性的属性描述对象(value
属性除外)。也就是说,configurable
属性控制了属性描述对象的可写性;- get
是一个函数,表示该属性的取值函数(getter),默认为
undefined; - set
是一个函数,表示该属性的存值函数(setter),默认为
undefined;
-
Object.getOwnPropertyDescriptor()
方法可以获取属性描述对象。它的第一个参数是目标对象,第二个参数是一个字符串,对应目标对象的某个属性名。Object.getOwnPropertyDescriptor()
方法只能用于对象自身的属性,不能用于继承的属性。 -
Object.getOwnPropertyNames
方法返回一个数组,成员是参数对象自身的全部属性的属性名,不管该属性是否可遍历。 -
Object.defineProperty()
方法允许通过属性描述对象,定义或修改一个属性,然后返回修改后的对象。 -
Object.defineProperties()
可以一次性定义或修改多个属性。 -
实例对象的
propertyIsEnumerable()
方法返回一个布尔值,用来判断某个属性是否可遍历。注意,这个方法只能用于判断对象自身的属性,对于继承的属性一律返回false
。 -
属性描述对象的各个属性称为“元属性”,因为它们可以看作是控制属性的属性。
value
属性是目标属性的值。writable
属性是一个布尔值,决定了目标属性的值(value)是否可以被改变。enumerable
(可遍历性)返回一个布尔值,表示目标属性是否可遍历。configurable
(可配置性)返回一个布尔值,决定了是否可以修改属性描述对象。- 存值函数称为
setter
,使用属性描述对象的set
属性;取值函数称为getter
,使用属性描述对象的get
属性。
-
JavaScript 提供了三种冻结方法,最弱的一种是
Object.preventExtensions
,其次是Object.seal
,最强的是Object.freeze
。 -
Object.preventExtensions
方法可以使得一个对象无法再添加新的属性。 -
Object.isExtensible
方法用于检查一个对象是否使用了Object.preventExtensions
方法。也就是说,检查是否可以为一个对象添加属性。Object.isExtensible
方法,返回false
,表示已经不能添加新属性了。 -
Object.seal
方法使得一个对象既无法添加新属性,也无法删除旧属性。 -
Object.isSealed
方法用于检查一个对象是否使用了Object.seal
方法。如果使用了Object.seal
方法,这时Object.isExtensible
方法也返回false
。 -
Object.freeze
方法可以使得一个对象无法添加新属性、无法删除旧属性、也无法改变属性的值,使得这个对象实际上变成了常量。 -
Object.isFrozen
方法用于检查一个对象是否使用了Object.freeze
方法。 -
使用
Object.freeze
方法以后,Object.isSealed
将会返回true
,Object.isExtensible
返回false
。
Array 对象
构造函数
Array
是 JavaScript 的原生对象,同时也是一个构造函数,可以用它生成新的数组。
var arr = new Array(2);
arr.length // 2
arr // [ empty x 2 ]
上面代码中,Array()
构造函数的参数2
,表示生成一个两个成员的数组,每个位置都是空值。
如果没有使用new
关键字,运行结果也是一样的。
var arr = Array(2);
// 等同于
var arr = new Array(2);
考虑到语义性,以及与其他构造函数用法保持一致,建议总是加上new
。
Array()
构造函数有一个很大的缺陷,不同的参数个数会导致不一致的行为。
// 无参数时,返回一个空数组
new Array() // []
// 单个正整数参数,表示返回的新数组的长度
new Array(1) // [ empty ]
new Array(2) // [ empty x 2 ]
// 非正整数的数值作为参数,会报错
new Array(3.2) // RangeError: Invalid array length
new Array(-3) // RangeError: Invalid array length
// 单个非数值(比如字符串、布尔值、对象等)作为参数,
// 则该参数是返回的新数组的成员
new Array('abc') // ['abc']
new Array([1]) // [Array[1]]
// 多参数时,所有参数都是返回的新数组的成员
new Array(1, 2) // [1, 2]
new Array('a', 'b', 'c') // ['a', 'b', 'c']
可以看到,Array()
作为构造函数,行为很不一致。因此,不建议使用它生成新数组,直接使用数组字面量是更好的做法。
// bad
var arr = new Array(1, 2);
// good
var arr = [1, 2];
注意,如果参数是一个正整数,返回数组的成员都是空位。虽然读取的时候返回undefined
,但实际上该位置没有任何值。虽然这时可以读取到length
属性,但是取不到键名。
var a = new Array(3);
var b = [undefined, undefined, undefined];
a.length // 3
b.length // 3
a[0] // undefined
b[0] // undefined
0 in a // false
0 in b // true
上面代码中,a
是Array()
生成的一个长度为3的空数组,b
是一个三个成员都是undefined
的数组,这两个数组是不一样的。读取键值的时候,a
和b
都返回undefined
,但是a
的键名(成员的序号)都是空的,b
的键名是有值的。
静态方法
Array.isArray()
Array.isArray
方法返回一个布尔值,表示参数是否为数组。它可以弥补typeof
运算符的不足。
var arr = [1, 2, 3];
typeof arr // "object"
Array.isArray(arr) // true
上面代码中,typeof
运算符只能显示数组的类型是Object
,而Array.isArray
方法可以识别数组。