ES6 数值的扩展、数组的扩展

ES6 数值的扩展、数组的扩展

一、数值的扩展

1，二进制和八进制的表示

ES6提供了二进制和八进制数值的新的写法
二进制前缀：0b、0B
八进制前缀：0o、0O

2,Number.isFinite() 和 Number.isNaN() 方法

• Number.isFinite() 用来检验一个数值是否非无穷（infinite）。
  例：

 //infinite  极大的 无法测量的 无穷
        console.log(Number.isFinite(5));          //true
        console.log(Number.isFinite(-3));         //true
        console.log(Number.isFinite(Infinity));   //false
        console.log(Number.isFinite(-Infinity));  //false
        console.log(Number.isFinite('45'));       //false
        console.log(Number.isFinite('abc'));      //false
        console.log(Number.isFinite(true));       //false

• Number.isNaN() 用来检测一个值是否为NaN ,是NaN返回true,否则返回flase。

注：以上两种方法不能将非数值的值转为数
值进行判断，两个新方法只对数值有效，非数值一律返回false。

3.Number.parseInt()和Number.parseFloat()

• ES6将全局方法parseInt()和parseFloat()移植到了Number对象上面，两个方法的行为完全保持不变。
  （这样做的目的，是逐步减少全局性方法，使得语言逐步模块化。）

4. Number.isInteger()

• Number.isInteger()用来判断一个值是否为整数。
  在js中，整数和浮点数是同样的储存方法，所以5和5.0被视为同一个值。例:

Number.isInteger(5)；      //true
Number.isInteger(5.0)；    //true
Number.isInteger(5.23)；   //false

5. Number.EPSILON

• Number.EPSILON 是ES6在Number对象上新增的一个极小的常量，用于为浮点数计算，设置一个误差范围。

这是因为浮点数的计算是不精确的，如果这个误差小于Number.EPSILON这个常量，我们就可以认为得到了正确的结果。

6.安全整数和Number.isSafeInteger()

JavaScript能够准确表示的整数范围在-2^53 到2^53 之间（不含两个端点），超过这个范围，无法精确表示这个值。
ES6引入了Number.MAX_SAFE_INTEGER 和Number.MIN_SAFE_INTEGER这两个常量，用来表示这个范围的上下限。

• Number.isSafeInteger()则是用来判断一个整数是否落在这两个常量之间。

注：验证运算结果是否落在安全整数的范围时，不要只验证运算结果，而要同时验证参与运算的每个值。

7. Math对象的扩展

• Math.trunc() 方法用于去除一个数的小数部分，返回整数部分。对于非数值，会在内部使用Number方法将其先转为数值。对于空值和无法截取整数的值，返回NaN。

• Math.sign() 方法用来判断一个数到底是正数、负数、还是零。
  参数为正数，返回+1；
  参数为负数，返回­1；
  参数为0，返回0；
  参数为­0，返回­0;
  其他值，返回NaN。

• Math.cbrt()方法用于计算一个数的立方根。对于非数值， Math.cbrt() 方法内部会先使用Number方法将其转为数值。

• Math.clz32()方法：在JavaScript中，整数是使用32位二进制形式表示，Math.cbrt() 方法返回一个数的32位无符号整数形式有几个前导0。

• Math.imul()方法返回两个数以32位带符号整数形式相乘的结果，返回的也是一个32位的带符号整数。

• Math.fround()方法返回一个数的单精度浮点数形式。

• Math.hypot()方法返回所有参数的平方和的平方根。例：

 Math.hypot(3，4);    //5
 Math.hypot(NaN);     //NaN

• 对数方法：
  1 , Math.expm1()： Math.expm1(x)返回
  2, Math.log1p() : Math.log1p(x)方法返回1+x的自然对数，即Math.log(1+x) 。如果x小于­1，返回NaN 。
  3, Math.log10() : Math.log10(x)返回以10为底的x的对数。如果x小于0，则返回NaN。
  4,Math.log2() : Math.log2(x)返回以2为底的x的对数。如果x小于0，则返回NaN。
• 三角函数方法：
  Math.sinh(x) 返回x的双曲正弦（hyperbolic sine）
  Math.cosh(x) 返回x的双曲余弦（hyperbolic cosine）
  Math.tanh(x) 返回x的双曲正切（hyperbolic tangent）
  Math.asinh(x) 返回x的反双曲正弦（inverse hyperbolic sine）
  Math.acosh(x) 返回x的反双曲余弦（inverse hyperbolic cosine）
  Math.atanh(x) 返回x的反双曲正切（inverse hyperbolic tangent）

8.指数运算符 : **

2**2    //4
2**0    //1

二、数组的扩展

1. Array.from()

• Array.from()方法用于将两类对象转为真正的数组：类似数组的对象（array­like object）和可遍历（iterable）的对象（包括ES6新增的数据结构Set和Map）。

let obj={
'0':'a';
'1':'b';
'2':'c';
}
let arr=Array.from(obj);   //['a','b','c']

实际应用中，常见的类似数组的对象是DOM操作返回的NodeList集合，以及函数内部的arguments对
象。Arrat.from都可以将它们转为真正的数组。
而且，任何有length属性的对象，都可以通过Array.from方法转为数组，而此时扩展运算符(…)就无法转换。

• Array.from 还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放
  入返回的数组。例：

Array.from([1,4,3],x=>x*x);   //[1,16,9]
//等同于
Array.map([1,4,3],x=>x*x);    //[1,16,9]

• Array.from的另一个应用是，将字符串转为数组，然后返回字符串的长度。因为它能正确处理各种Unicode字符，可以避免JavaScript将大于\uFFFF的Unicode字符，错算作两个字符。

2，Array.of()

• Array.of() 方法用于将一组值，转换为数组。 返回参数值组成的数组。如果没有参数，就返回一个空数组。 这个方法的主要目的，是弥补数组构造函数 Array() 的不足。因为Array() 方法没有参数、一个参数、三个参数时，返回结果都不一样。只有当参数个数不少于2个时，Array() 才会返回由参数组成的新数组。参数个数只有一个时，实际上是指定数组的长度。
  Array.of() 基本上可以用来替代 Array() 或new Array() ，并且不存在由于参数不同而导致的重载。它的行为非常统一。

3， 数组实例的copyWithin()

• 数组实例的copyWithin()方法，在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。这个方法，会改变当前数组。
  它接受三个参数。
  target（必需）：从该位置开始替换数据。
  start（可选）：从该位置开始读取数据，默认为0。如果为负值，表示倒数。
  end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示倒数。
  这三个参数都应该是数值，如果不是，会自动转为数值。

//将3号位复制到0号位
[1,2,3,4,5,6].copyWithin(0,3,4);
//[4,2,3,4,5,6]

[1,2,3,4,5].copyWithin(0,3);
//[4,5,3,4,5]

4, 数组实例的find()和findIndex()

• 数组实例的find()方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true 的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined 。

//代码找出数组中第一个小于0的成员。
[1,2,-1,0,4,6].find(x=>x<0)  
//-1

find方法的回调函数可以接受三个参数，依次为当前的值、当前的位置和原数组。

[1,2,3,6,10,20,30].find(function(value,index,arr){
return value > 10;
})
//20

• 数组实例的findIndex() 方法的用法与find()方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成
  员都不符合条件，则返回-1 。

5. 数组实例的fill()

• fill()方法使用给定值，填充一个数组。

[1,2,3].fill(7);
//[7,7,7]
new Array(3).fill(7);
//[7,7,7]

上面代码表明，fill方法用于空数组的初始化非常方便。数组中已有的元素，会被全部抹去。

• fill方法还可以接受第二个和第三个参数，用于指定填充的起始位置和结束位置。

['a','b','c'].fill(3，1，2);
//['a',3,'c']

上面代码表示，fill方法从1号位开始，向原数组填充7，到2号位之前结束。

6，数组实例的entries()，keys()和values()

• ES6提供三个新的方法：entries()，keys() 和values()——用于遍历数组。它们都返回一个遍历器对象 ，可以用 for …of 循环进行遍历，唯一的区别是 entries() 是对键值对的遍历 , keys()是对键名的遍历 , values() 是对键值的遍历。

for(let index of(['a','b].keys())){
    console.log(index);
    //0    1
}

for(let elem of(['a','b'].values())){
    console.log(elem);
    //'a'    'b'
}

for(let ['index','elem'] of(['a','b].entries())){
    console.log(index,elem);
    //0    'a'
    //1    'b'
}

如果不使用for…of循环，可以手动调用遍历器对象的next方法，进行遍历。

let arr=['a','b','c'];
let entries=arr.entries();
console.log(entries.next().value);  //[0,'a']
console.log(entries.next().value);
//[2,'b']
console.log(entries.next().value);
//[3,'c']

7，数组实例的includes()

• Array.prototype.includes方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。
  该方法的第二个参数表示搜索的起始位置，默认为0。如果第二个参数为负数，则表示倒数的位置，如果这时它 大于数组长度（比如第二个参数为­4，但数组长度为3），则会重置为从0开始。

[1,2,3,4]includes(3); //true
[1,2,3,4]includes(7); //false
[1,2,3,4]includes(3,3); //false

8. 数组的空位

• 数组的空位指，数组的某一个位置没有任何值。比如，Array构造函数返回的数组都是空位。
  注 : 空位不是undefined，一个位置的值等于undefined，依然是有值的。空位是没有任何值，in 运算符可以说明这一点。

0 in [undefined,undefined,undefined]   //true
0 in[,,]      //false

• ES5中，大多数情况会忽略空位
  forEach(),filter(),every(),some()都会跳过空位
  map()会跳过空位，但会保留这个值
  join(),toString()会将这个空位视为undefined,而undefined和null会被处理成空字符串。 ES6则是明确将空位转为undefined

9,数组推导

• 数组推导（array comprehension）提供简洁写法，允许直接通过现有数组生成新数组。

var arr1=[1,2,3,4];
var arr2=[for(i of arr1)i*2];
//arr2:  [2,4,6,8]

上面代码表示，通过 for…of 结构，数组arr2直接在arr1的基础上生成。
注意，数组推导中， for…of 结构总是写在前面，返回的表达式写在后面。for…of 后面还可以附加if语句，用来设定循环的限制条件。

var years=[1954,1979,1990,2006,2010,2014];
[for(y of years) if(y>2000) y];
//2006,2010,2014