JavaScript小知识点总结：标准库

1.Object作为构造函数使用时，可以接受一个参数。如果该参数是一个对象，则直接返回这个对象；如果是一个原始类型的值，则返回该值对应的包装对象。

2.所有构造函数都有一个prototype属性，指向一个原型对象。凡是定义在Object.prototype对象上面的属性和方法，将被所有实例对象共享。

3.Object.keys方法和Object.getOwnPropertyNames方法很相似，一般用来遍历对象的属性。它们的参数都是一个对象，都返回一个数组，该数组的成员都是对象自身的（而不是继承的）所有属性名。它们的区别在于，Object.keys方法只返回可枚举的属性，Object.getOwnPropertyNames方法还返回不可枚举的属性名。

4.对象属性模型的相关方法：

Object.getOwnPropertyDescriptor()：获取某个属性的attributes对象。
Object.defineProperty()：通过attributes对象，定义某个属性。
Object.defineProperties()：通过attributes对象，定义多个属性。
Object.getOwnPropertyNames()：返回直接定义在某个对象上面的全部属性的名称。

5.控制对象状态的方法：

Object.preventExtensions()：防止对象扩展。
Object.isExtensible()：判断对象是否可扩展。
Object.seal()：禁止对象配置。
Object.isSealed()：判断一个对象是否可配置。
Object.freeze()：冻结一个对象。
Object.isFrozen()：判断一个对象是否被冻结。

6.原型链相关方法：

Object.create()：生成一个新对象，并该对象的原型。
Object.getPrototypeOf()：获取对象的Prototype对象。

7.Object实例对象的方法，主要有以下六个：

valueOf()：返回当前对象对应的值。
toString()：返回当前对象对应的字符串形式。
toLocaleString()：返回当前对象对应的本地字符串形式。
hasOwnProperty()：判断某个属性是否为当前对象自身的属性，还是继承自原型对象的属性。
isPrototypeOf()：判断当前对象是否为另一个对象的原型。
propertyIsEnumerable()：判断某个属性是否可枚举。

8.不同数据类型的Object.prototype.toString方法返回值如下：

Object.prototype.toString.call(value) =>

数值：返回[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]。

9.Array是JavaScript的内置对象，同时也是一个构造函数，可以用它生成新的数组。

10.Array.isArray方法用来判断一个值是否为数组。它可以弥补typeof运算符的不足。

11.Array实例的方法：

valueOf()方法返回数组本身。
toString()方法返回数组字符串形式
push()方法用于在数组尾部添加一个或者多个元素，并返回添加新元素后数组的长度，注意，该方法会改变数组长度。push()还可以向对象添加属性，且对象有一个length属性（
```
var a = {a: 1};

[].push.call(a, 2);
a // {a:1, 0:2, length: 1}

[].push.call(a, [3]);
a // {a:1, 0:2, 1:[3], length: 2}
```
）
pop()方法删除数组最后一个元素，并返回该元素。该方法改变原数组。
join()方法以参数作为分隔符，将所有数组成员组成一个字符串返回。无参数则以逗号隔开。
concat()方法用于多个数组合并，将新数组添加到原数组尾部，返回一个新的数组，原数组不变。（如果不提供参数，concat方法返回当前数组的一个浅拷贝。所谓“浅拷贝”，指的是如果数组成员包括复合类型的值（比如对象），则新数组拷贝的是该值的引用。）
shift()方法用于删除数组第一个元素。并返回该元素。
unshift()方法用于在数组第一个位置添加元素。返回新数组的长度。
reserve()方法用于颠倒数组中的元素的顺序，返回改变后的数组。
slice()方法用于提取原数组的一部分，返回新数组，原数组不变。第一个参数是开始位置，第二个参数为终止位置（该位置的元素不包含在内），第二个参数省略则一直返回原数组最后一个成员。参数为负，则表示倒数计算的位置。
splice()方法删除原数组一部分成员，并可以在删除的位置添加新成员，返回值为删除的元素，该方法改变原数组。第一个参数为删除开始位置，第二个参数是删除的个数。如果后面还有参数则是添加的新成员。起始位置如果是负数，就表示从倒数位置开始删除。如果只是单纯地插入元素，splice方法的第二个参数可以设为0。如果只提供第一个参数，等同于将原数组在指定位置拆分成两个数组。
sort()方法对数组成员进行排序，默认是按照字典顺序排序。排序后，原数组将被改变。如果想让sort方法按照自定义方式排序，可以传入一个函数作为参数，表示按照自定义方法进行排序。该函数本身又接受两个参数，表示进行比较的两个元素。如果返回值大于0，表示第一个元素排在第二个元素后面；其他情况下，都是第一个元素排在第二个元素前面。
map方法是对数组的所有成员依次调用依次函数，根据函数结果返回一个新的数组。map方法接受一个函数作为参数。函数调用时，map方法传入三个参数，分别是当前成员、当前位置和数组本身。（
```
[1, 2, 3].map(function(elem, index, arr) {
  return elem * index;
});
```
```
// [0, 2, 6]
```
）map方法的回调函数的三个参数之中，elem为当前成员的值，index为当前成员的位置，arr为原数组（[1, 2, 3]）。map还可以接受第二个参数，表示回掉函数执行时this所指的对象。
```
var arr = ['a', 'b', 'c'];

[1, 2].map(function(e){
  return this[e];
}, arr)
// ['b', 'c']上面代码通过map方法的第二个参数，将回调函数内部的this对象，指向arr数组。map方法不会跳过undefined和null，但是会跳过空位。
```
forEach方法和map很相似，也是遍历数组所有成员，执行某种操作，但是forEach方法一般不返回值。只对数据进行操作。它接受三个参数，分别是当前位置的值、当前位置的编号和整个数组。forEach方法也可以接受第二个参数，用来绑定回调函数的this关键字。forEach方法不会跳过undefined和null，但会跳过空位。

filter方法的参数是一个函数，所有的数组成员依次执行这个函数，返回结果为true的一个新数组，该方法不会改变原数组。

[1, 2, 3, 4, 5].filter(function (elem) {
  return (elem > 3);
})
// [4, 5]filter方法的参数函数可以接受三个参数，第一个参数是当前数组成员的值，这是必需的，后两个参数是可选的，分别是当前数组成员的位置和整个数组。filter方法还可以接受第二个参数，指定测试函数所在的上下文对象（即this对象）。

some(),every()这两个方法用来判断数组成员是否满足某种条件，他们接受函数作为参数。返回一个布尔值。该函数接受三个参数，当前位置成员，当前的位置索引以及整个数组。some只要一个数组成员返回值是true，则整个some方法返回的都是true。否则，则返回false。every方法则是所有的返回的值都为true，才返回true，否则是false。对于空数组，some方法返回false，every返回true。回调函数都不执行。
reduce(),reduceRight()依次处理数组的每一个成员，最终累计成一个值。它们的差别是，reduce是从左到右处理（从第一个成员到最后一个成员），reduceRight则是从右到左（从最后一个成员到第一个成员），其他完全一样。这两个方法的第一个参数都是一个函数。该函数接受以下四个参数。

累积变量，默认为数组的第一个成员
当前变量，默认为数组的第二个成员
当前位置（从0开始）

原数组这四个参数之中，只有前两个是必须的，后两个则是可选的。这四个参数之中，只有前两个是必须的，后两个则是可选的。

[1, 2, 3, 4, 5].reduce(function(x, y){
  console.log(x, y)
  return x + y;
});
// 1 2
// 3 3
// 6 4
// 10 5
//最后结果：15

[1, 2, 3, 4, 5].reduce(function(x, y){
  return x + y;
}, 10);
// 25   上面代码指定参数x的初值为10，所以数组从10开始累加，最终结果为25。注意，这时y是从数组的第一个成员开始遍历。第二个参数相当于设定了默认值，处理空数组时尤其有用。

function add(prev, cur) {
  return prev + cur;
}

[].reduce(add)
// TypeError: Reduce of empty array with no initial value
[].reduce(add, 1)
// 1                                                   下面是reduceRight示例

function substract(prev, cur) {
  return prev - cur;
}

[3, 2, 1].reduce(substract) // 0
[3, 2, 1].reduceRight(substract) // -4

indexOf()返回给定元素在数组中第一次出现的位置，如果没有出现则返回-1。lastIndexOf方法返回给定元素在数组中最后一次出现的位置，如果没有出现则返回-1。如果数组中包含NaN，这两个方法不适用，即无法确定数组成员是否包含NaN。

12.包装对象：数组和函数本质上是对象，数组、字符串、布尔值在一定条件下也会自动转换成对象，也就是原始类型的包装对象。所谓“包装对象”，就是分别与数值、字符串、布尔值相对应的Number、String、Boolean三个原生对象。这三个原生对象可以把原始类型的值变成（包装成）对象。

var v1 = new Number(123);

var v2 = new String('abc');

var v3 = new Boolean(true)。

13.JavaScript设计包装对象的最大目的，首先是使得JavaScript的“对象”涵盖所有的值。其次，使得原始类型的值可以方便地调用特定方法。Number、String和Boolean如果不作为构造函数调用（即调用时不加new），常常用于将任意类型的值转为数值、字符串和布尔值。

Number(123) // 123

String('abc') // "abc"

Boolean(true) // true

14.包装对象实例的方法：

valueOf方法返回包装对象实例对应的原始类型的值。
toString方法返回实例对应的字符串形式。

15.原始类型的值，可以自动当作对象调用，即调用各种对象的方法和参数。这时，JavaScript引擎会自动将原始类型的值转为包装对象，在使用后立刻销毁。

var str = 'abc';
str.length // 3

// 等同于
var strObj = new String(str)
// String {
//   0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: "abc"
// }
strObj.length // 3

上面代码中，字符串abc的包装对象有每个位置的值、有length属性、还有一个内部属性[[PrimitiveValue]]保存字符串的原始值。这个[[PrimitiveValue]]内部属性，外部是无法调用，仅供ValueOf或toString这样的方法内部调用。

这个临时对象是只读的，无法修改。所以，字符串无法添加新属性。

如果包装对象与原始类型值进行混合运算，包装对象会转化为原始类型（实际是调用自身的valueOf方法）

new Number(123) + 123 // 246

new String('abc') + 'abc' // "abcabc"

16.三种包装对象还可以在原型上添加自定义方法和属性，供原始类型的值直接调用。

17.Boolean对象是JavaScript的三个包装对象之一。作为构造函数，它主要用于生成布尔值的包装对象的实例。

var b = new Boolean(true);

typeof b // "object"
b.valueOf() // true

上面代码的变量b是一个Boolean对象的实例，它的类型是对象，值为布尔值true。这种写法太繁琐，几乎无人使用，直接对变量赋值更简单清晰。false对应的包装对象实例，布尔运算结果也是true。

18.Boolean对象除了可以作为构造函数，还可以单独使用，将任意值转为布尔值。这时Boolean就是一个单纯的工具方法。

Boolean(undefined) // false
Boolean(null) // false
Boolean(0) // false
Boolean('') // false
Boolean(NaN) // false

Boolean(1) // true
Boolean('false') // true
Boolean([]) // true
Boolean({}) // true
Boolean(function () {}) // true
Boolean(/foo/) // true

上面代码中几种得到true的情况，都值得认真记住。

使用双重的否运算符（!）也可以将任意值转为对应的布尔值。

!!undefined // false
!!null // false
!!0 // false
!!'' // false
!!NaN // false
!!1 // true
!!'false' // true
!![] // true
!!{} // true
!!function(){} // true
!!/foo/ // true

最后，对于一些特殊值，Boolean对象前面加不加new，会得到完全相反的结果，必须小心。

if (Boolean(false)) {
  console.log('true');
} // 无输出

if (new Boolean(false)) {
  console.log('true');
} // true

if (Boolean(null)) {
  console.log('true');
} // 无输出

if (new Boolean(null)) {
  console.log('true');
} // true

19.Number对象是数值对应的包装对象，可以作为构造函数使用，也可以作为工具函数使用。

20.Number对象拥有以下一些属性。

Number.POSITIVE_INFINITY：正的无限，指向Infinity。
Number.NEGATIVE_INFINITY：负的无限，指向-Infinity。
Number.NaN：表示非数值，指向NaN。
Number.MAX_VALUE：表示最大的正数，相应的，最小的负数为-Number.MAX_VALUE。
Number.MIN_VALUE：表示最小的正数（即最接近0的正数，在64位浮点数体系中为5e-324），相应的，最接近0的负数为-Number.MIN_VALUE。
Number.MAX_SAFE_INTEGER：表示能够精确表示的最大整数，即9007199254740991。
Number.MIN_SAFE_INTEGER：表示能够精确表示的最小整数，即-9007199254740991。

21.Number对象实例的方法：

Number.prototype.toString()用来将一个数值转为字符串形式。

toString方法可以接受一个参数，表示输出的进制。如果省略这个参数，默认将数值先转为十进制，再输出字符串；否则，就根据参数指定的进制，将一个数字转化成某个进制的字符串。

(10).toString(2) // "1010"
(10).toString(8) // "12"
(10).toString(16) // "a"

上面代码中，之所以要把10放在括号里，是为了表明10是一个单独的数值，后面的点表示调用对象属性。如果不加括号，这个点会被JavaScript引擎解释成小数点，从而报错。只要能够让JavaScript引擎不混淆小数点和对象的点运算符，各种写法都能用。除了为10加上括号，还可以在10后面加两个点，JavaScript会把第一个点理解成小数点（即10.0），把第二个点理解成调用对象属性，从而得到正确结果。这实际上意味着，可以直接对一个小数使用toString方法。

10.5.toString() // "10.5"
10.5.toString(2) // "1010.1"
10.5.toString(8) // "12.4"

Number.prototype.toFixed()方法用于将一个数转为指定位数的小数，返回这个小数对应的字符串。

(10).toFixed(2) // "10.00"
10.005.toFixed(2) // "10.01"

上面代码分别将10和10.005转成2位小数的格式。其中，10必须放在括号里，否则后面的点运算符会被处理小数点，而不是表示调用对象的方法；而10.005就不用放在括号里，因为第一个点被解释为小数点，第二个点就只能解释为点运算符。toFixed方法的参数为指定的小数位数，有效范围为0到20，超出这个范围将抛出RangeError错误。

Number.prototype.toExponential()方法用于将一个数转为科学计数法形式。toExponential方法的参数表示小数点后有效数字的位数，范围为0到20，超出这个范围，会抛出一个RangeError。

Number.prototype.toPrecision()方法用于将一个数转为指定位数的有效数字。

(12.34).toPrecision(1) // "1e+1"
(12.34).toPrecision(2) // "12"
(12.34).toPrecision(3) // "12.3"
(12.34).toPrecision(4) // "12.34"
(12.34).toPrecision(5) // "12.340"

toPrecision方法的参数为有效数字的位数，范围是1到21，超出这个范围会抛出RangeError错误。

22.String对象提供的静态方法（即定义在对象本身，而不是定义在对象实例的方法），主要是fromCharCode()。该方法的参数是一系列Unicode码点，返回对应的字符串。

String.fromCharCode(104, 101, 108, 108, 111)
// "hello"

上面代码中，fromCharCode方法接受5个Unicode码点作为参数，返回它们组成的字符串。

注意，该方法不支持Unicode码点大于0xFFFF的字符，即传入的参数不能大于0xFFFF。

23.实例对象的属性和方法。

charAt()方法返回指定位置的字符，参数从0开始。如果参数为负数，或大于等于字符串的长度，charAt返回空字符串
```
'abc'.charAt(1) // "b"
```
charCodeAt()方法返回指定位置字符的Unicode码点
```
'abc'.charCodeAt(1) // 98
```
上面代码中，abc的1号位置的字符是b，它的Unicode码点是98。如果没有任何参数，charCodeAt返回首字符的Unicode码点。如果参数为负数，或大于等于字符串的长度，charCodeAt返回NaN。
concat()方法用于连接2个字符串，返回一个新字符串。不改变原字符串。该方法接受多个参数。如果参数不是字符串，concat方法会将其先转换成字符串，然后再连接。
slice()方法用于从原字符串中提取字符串并返回。不改变原字符串。它的第一个参数是子字符串的开始位置，第二个参数是子字符串的结束位置（不含该位置）。如果省略第二个参数，则表示子字符串一直到原字符串结束。如果参数是负值，表示从结尾开始倒数计算的位置，即该负值加上字符串长度。
```
'JavaScript'.slice(-6) // "Script"
'JavaScript'.slice(0, -6) // "Java"
'JavaScript'.slice(-2, -1) // "p"
```
如果第一个参数大于第二个参数，slice方法返回一个空字符串。
substring()方法用于从原字符串取出子字符串并返回，不改变原字符串。它与slice作用相同，但有一些奇怪的规则，因此不建议使用这个方法，优先使用slice。substring方法的第一个参数表示子字符串的开始位置，第二个位置表示结束位置。如果第一个参数大于第二个参数，substring方法会自动更换两个参数的位置。如果参数是负数，substring方法会自动将负数转为0。
substr()方法用于从原字符串取出子字符串并返回，不改变原字符串。substr方法的第一个参数是子字符串的开始位置，第二个参数是子字符串的长度。如果第一个参数是负数，表示倒数计算的字符位置。如果第二个参数是负数，将被自动转为0，因此会返回空字符串。
indexOf(),lastIndexOf()两个方法用于确定一个字符串在另一个字符串中的位置，都返回一个整数，表示匹配开始的位置。如果返回-1，就表示不匹配。两者的区别在于，indexOf从字符串头部开始匹配，lastIndexOf从尾部开始匹配。
trim()方法用于去除字符串两端的空格，返回一个新字符串，不改变原字符串。该方法去除的不仅是空格，还包括制表符（\t、\v）、换行符（\n）和回车符（\r）。
toLowerCase()用于字符串转成小写to UpperCase()用于字符串转换成大写。他们返回一个新字符串，不改变原字符串。
localeCompare方法用于比较两个字符串。它返回一个整数，如果小于0，表示第一个字符串小于第二个字符串；如果等于0，表示两者相等；如果大于0，表示第一个字符串大于第二个字符串。'B'.localeCompare('a') // 1
match()方法用于确定原字符串是否匹配某个子字符串，返回一个数组，成员为匹配的第一个字符串。如果没有找到匹配，则返回null。返回数组还有index属性和input属性，分别表示匹配字符串开始的位置和原始字符串。
search()方法等同于match，但是返回值为匹配的第一个位置。如果没有找到匹配，则返回-1。
replace()方法用于替换匹配的字符串。一般情况下值替换第一个匹配的。'aaa'.replace('a', 'b') // "baa"
split()方法按照给定规则分割字符串，返回一个由分割出来的子字符串组成的数组。如果省略参数，则返回数组的唯一成员就是原字符串。
split方法还可以接受第二个参数，限定返回数组的最大成员数。
```
'a|b|c'.split('|', 0) // []
'a|b|c'.split('|', 1) // ["a"]
'a|b|c'.split('|', 2) // ["a", "b"]
'a|b|c'.split('|', 3) // ["a", "b", "c"]
'a|b|c'.split('|', 4) // ["a", "b", "c"]
```
上面代码中，split方法的第二个参数，决定了返回数组的成员数。

24.Math对象提供以下一些数学方法。

Math.abs()：绝对值
Math.ceil()：向上取整
Math.floor()：向下取整
Math.max()：最大值
Math.min()：最小值
Math.pow()：指数运算
Math.sqrt()：平方根
Math.log()：自然对数
Math.exp()：e的指数
Math.round()：四舍五入
Math.random()：随机数

25.Date对象接受从1970年1月1日00:00:00 UTC开始计算的毫秒数作为参数。这意味着如果将Unix时间戳（单位为秒）作为参数，必须将Unix时间戳乘以1000。Date构造函数的参数可以是一个负数，表示1970年1月1日之前的时间。Date对象还接受一个日期字符串作为参数，返回所对应的时间。两个日期对象进行减法运算，返回的就是它们间隔的毫秒数；进行加法运算，返回的就是连接后的两个字符串。

26.Date.now方法返回当前距离1970年1月1日 00:00:00 UTC的毫秒数（Unix时间戳乘以1000）。Date.parse方法用来解析日期字符串，返回距离1970年1月1日 00:00:00的毫秒数。

默认情况下，Date对象返回的都是当前时区的时间。Date.UTC方法可以返回UTC时间（世界标准时间）。该方法接受年、月、日等变量作为参数，返回当前距离1970年1月1日 00:00:00 UTC的毫秒数。

// 格式
Date.UTC(year, month[, date[, hrs[, min[, sec[, ms]]]]])

// 用法
Date.UTC(2011, 0, 1, 2, 3, 4, 567)
// 1293847384567

该方法的参数用法与Date构造函数完全一致，比如月从0开始计算，日期从1开始计算。

27.Date.prototype.valueOf()方法返回实例对象距离1970年1月1日00:00:00 UTC对应的毫秒数，该方法等同于getTime方法。

28.JSON.stringify方法用于将一个值转为字符串。该字符串符合 JSON 格式，并且可以被JSON.parse方法还原。需要注意的是，对于原始类型的字符串，转换结果会带双引号。

如果原始对象中，有一个成员的值是undefined、函数或 XML 对象，这个成员会被过滤。

var obj = {
  a: undefined,
  b: function () {}
};

JSON.stringify(obj) // "{}"

上面代码中，对象obj的a属性是undefined，而b属性是一个函数，结果都被JSON.stringify过滤。

如果数组的成员是undefined、函数或 XML 对象，则这些值被转成null。

var arr = [undefined, function () {}];
JSON.stringify(arr) // "[null,null]"

上面代码中，数组arr的成员是undefined和函数，它们都被转成了null。

正则对象会被转成空对象。

JSON.stringify方法还可以接受一个数组，作为第二个参数，指定需要转成字符串的属性。

var obj = {
  'prop1': 'value1',
  'prop2': 'value2',
  'prop3': 'value3'
};

var selectedProperties = ['prop1', 'prop2'];

JSON.stringify(obj, selectedProperties)
// "{"prop1":"value1","prop2":"value2"}"

上面代码中，JSON.stringify方法的第二个参数指定，只转prop1和prop2两个属性。第二个参数指定只对对象的属性有效，对数组无效。第二个参数还可以是一个函数，用来更改JSON.stringify的默认行为。

function f(key, value) {
  if (typeof value === "number") {
    value = 2 * value;
  }
  return value;
}

JSON.stringify({ a: 1, b: 2 }, f)
// '{"a": 2,"b": 4}'

上面代码中的f函数，接受两个参数，分别是被转换的对象的键名和键值。如果键值是数值，就将它乘以2，否则就原样返回。

JSON.stringify还可以接受第三个参数，用于增加返回的JSON字符串的可读性。如果是数字，表示每个属性前面添加的空格（最多不超过10个）；如果是字符串（不超过10个字符），则该字符串会添加在每行前面。

JSON.stringify({ p1: 1, p2: 2 }, null, 2);

/*

"{

"p1": 1,

"p2": 2

}"

*/

JSON.stringify({ p1:1, p2:2 }, null, '|-');

/*

"{

|-"p1": 1,

|-"p2": 2

}"

*/

29.如果JSON.stringify的参数对象有自定义的toJSON方法，那么JSON.stringify会使用这个方法的返回值作为参数，而忽略原对象的其他属性。

var user = {

firstName: '三',

lastName: '张',

get fullName(){

return this.lastName + this.firstName;

},

toJSON: function () {

var data = {

firstName: this.firstName,

lastName: this.lastName

};

return data;

}

};

JSON.stringify(user)

// "{"firstName":"三","lastName":"张"}"

30.JSON.parse方法用于将JSON字符串转化成对象。如果传入的字符串不是有效的JSON格式，JSON.parse方法将报错。JSON.parse方法可以接受一个处理函数，用法与JSON.stringify方法类似。

31.console.log如果第一个参数是格式字符串（使用了格式占位符），console.log方法将依次用后面的参数替换占位符，然后再进行输出。

console.log(' %s + %s = %s', 1, 1, 2)

// 1 + 1 = 2

console.log方法支持以下占位符，不同格式的数据必须使用对应格式的占位符。

%s 字符串
%d 整数
%i 整数
%f 浮点数
%o 对象的链接
%c CSS格式字符串

32.console.dir()方法用来对一个对象进行检查（inspect），并以易于阅读和打印的格式显示。dirxml方法主要用于以目录树的形式，显示DOM节点。如果参数不是DOM节点，而是普通的JavaScript对象，console.dirxml等同于console.dir。

33.console.assert()方法接受两个参数，第一个参数是表达式，第二个参数是字符串。只有当第一个参数为false，才会输出第二个参数，否则不会有任何结果。

34.time(),timeEnd()这两个方法用于计时，可以算出一个操作所花费的准确时间。

35.新建正则表达式有两种方法。一种是使用字面量，以斜杠表示开始和结束。

RegExp构造函数还可以接受第二个参数，表示修饰符（详细解释见下文）。

var regex = new RegExp('xyz', "i");
// 等价于
var regex = /xyz/i;

上面代码中，正则表达式/xyz/有一个修饰符i。

36.正则对象的test方法返回一个布尔值，表示当前模式是否能匹配参数字符串。带有g修饰符时，可以通过正则对象的lastIndex属性指定开始搜索的位置。如果正则模式是一个空字符串，则匹配所有字符串。

37.正则对象的exec方法，可以返回匹配结果。如果发现匹配，就返回一个数组，成员是每一个匹配成功的子字符串，否则返回null。如果正则对象是一个空字符串，则exec方法会匹配成功，但返回的也是空字符串。

38.JavaScript提供了一个内部数据结构，用来描述一个对象的属性的行为，控制它的行为。这被称为“属性描述对象”（attributes object）。每个属性都有自己对应的属性描述对象，保存该属性的一些元信息。

39.Object.getOwnPropertyDescriptor方法可以读出对象自身属性的属性描述对象。

var o = { p: 'a' };

Object.getOwnPropertyDescriptor(o, 'p')
// Object { value: "a",
//   writable: true,
//   enumerable: true,
//   configurable: true
// }

上面代码表示，使用Object.getOwnPropertyDescriptor方法，读取o对象的p属性的属性描述对象。

40.Object.defineProperty方法允许通过定义属性描述对象，来定义或修改一个属性，然后返回修改后的对象。它的格式如下。

Object.defineProperty(object, propertyName, attributesObject)

上面代码中，Object.defineProperty方法接受三个参数，第一个是属性所在的对象，第二个是属性名（它应该是一个字符串），第三个是属性的描述对象。如果属性已经存在，Object.defineProperty方法相当于更新该属性的属性描述对象。需要注意的是，Object.defineProperty方法和后面的Object.defineProperties方法，都有性能损耗，会拖慢执行速度，不宜大量使用。

41.

属性描述对象提供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。

42.属性描述对象的属性，被称为“元属性”，因为它可以看作是控制属性的属性。

43.除了直接定义以外，属性还可以用存取器（accessor）定义。其中，存值函数称为setter，使用set命令；取值函数称为getter，使用get命令。存取器也可以使用Object.create方法定义。

44.JavaScript提供了三种方法，精确控制一个对象的读写状态，防止对象被改变。最弱一层的保护是Object.preventExtensions，其次是Object.seal，最强的Object.freeze。

Object.preventExtensions方法可以使得一个对象无法再添加新的属性。
Object.isExtensible方法用于检查一个对象是否使用了Object.preventExtensions方法。也就是说，检查是否可以为一个对象添加属性。
Object.seal方法使得一个对象既无法添加新属性，也无法删除旧属性。
Object.isSealed方法用于检查一个对象是否使用了Object.seal方法。
Object.freeze方法可以使得一个对象无法添加新属性、无法删除旧属性、也无法改变属性的值，使得这个对象实际上变成了常量。
Object.isFrozen方法用于检查一个对象是否使用了Object.freeze()方法。

posted @ 2017-03-21 23:16 cluod 阅读(479) 评论(0) 收藏举报

刷新页面返回顶部

cluod

JavaScript小知识点总结：标准库

公告