数值的扩展、数组的扩展

数值的扩展

1.二进制和八进制表示法

二进制和八进制数值的新的写法，分别用前缀0b（或0B）和0o（或0O）表示，如果要将0b和0o前缀的字符串数值转为十进制，要使用Number方法。

0b111110111 === 503 // true
0o767 === 503 // true

Number('0b111')  // 7
Number('0o10')  // 8

2.Number.isFinite(), Number.isNaN()

Number.isFinite()用来检查一个数值是否为有限的（finite），即不是Infinity。
Number.isNaN()用来检查一个值是否为NaN。
它们与传统的全局方法isFinite()和isNaN()的区别在于，传统方法先调用Number()将非数值的值转为数值，再进行判断，而这两个新方法只对数值有效。

3.Number.parseInt(), Number.parseFloat()

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

// ES5的写法
parseInt('12.34') // 12
parseFloat('123.45#') // 123.45

// ES6的写法
Number.parseInt('12.34') // 12
Number.parseFloat('123.45#') // 123.45

4.Number.isInteger()

Number.isInteger()用来判断一个数值是否为整数。JavaScript 内部，整数和浮点数采用的是同样的储存方法，所以 25 和 25.0 视为同一个值。如果数值的精度超过53个二进制位，第54位及后面的位就会被丢弃。如果一个数值的绝对值小于Number.MIN_VALUE（5E-324），即小于 JavaScript 能够分辨的最小值，会被自动转为 0。如果对数字精度要求过高，不推荐使用这个方法。

Number.isInteger(25) //true
Number.isInteger(25.1) //false

Number.isInteger(25) // true
Number.isInteger(25.0) // true

Number.isInteger(3.0000000000000002) // true
Number.isInteger(5E-325) // true         超过最小值，自动转为0

5.Number.EPSILON

Number.EPSILON是新增的一个极小的常量，根据规格，它表示 1 与大于 1 的最小浮点数之间的差。对于 64 位浮点数来说，大于 1 的最小浮点数相当于二进制的1.00…001，小数点后面有连续 51 个零。这个值减去 1 之后，就等于 2 的 -52 次方。能够帮助设置最小误差。

Number.EPSILON === Math.pow(2, -52)

function withinErrorMargin (left, right) {
  return Math.abs(left - right) < Number.EPSILON * Math.pow(2, 2);
}
0.1 + 0.2 === 0.3 // false
withinErrorMargin(0.1 + 0.2, 0.3) // true
1.1 + 1.3 === 2.4 // false
withinErrorMargin(1.1 + 1.3, 2.4) // true

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

Number.MAX_SAFE_INTEGER和Number.MIN_SAFE_INTEGER这两个常量表示整数范围在-2^53到 2^53之间的上下限。

Number.MAX_SAFE_INTEGER === Math.pow(2, 53) - 1

Number.isSafeInteger()则是用来判断一个整数是否落在这个范围之内。验证运算结果是否落在安全整数的范围内，不要只验证运算结果，而要同时验证参与运算的每个值。

Number.isSafeInteger = function (n) {
  return (typeof n === 'number' &&
    Math.round(n) === n &&
    Number.MIN_SAFE_INTEGER <= n &&
    n <= Number.MAX_SAFE_INTEGER);
}

function trusty (left, right, result) {
  if (
    Number.isSafeInteger(left) &&
    Number.isSafeInteger(right) &&
    Number.isSafeInteger(result)
  ) {
    return result;
  }
  throw new RangeError('Operation cannot be trusted!');
}

trusty(9007199254740993, 990, 9007199254740993 - 990)
// RangeError: Operation cannot be trusted!

trusty(1, 2, 3)
// 3

7.Math对象的扩展

（1）Math.trunc()去除一个数的小数部分，返回整数部分。对于非数值，Math.trunc内部使用Number方法将其先转为数值。对于空值和无法截取整数的值，返回NaN。
（2）Math.sign判断一个数到底是正数、负数、还是零。对于非数值，会先将其转换为数值。

它会返回五种值。
参数为正数，返回+1；
参数为负数，返回-1；
参数为 0，返回0；
参数为-0，返回-0;
其他值，返回NaN。

（3）Math.cbrt()计算一个数的立方根，对于非数值，内部先使用Number()方法将其转为数值。
（4）Math.clz32()将参数转为 32 位无符号整数的形式，然后返回这个 32 位值里面有多少个前导 0，对于小数，Math.clz32方法只考虑整数部分，对于空值或其他类型的值，Math.clz32方法会将它们先转为数值，然后再计算。

Math.clz32(1) // 31
Math.clz32(1 << 2) // 29
Math.clz32(1 << 29) // 2

Math.clz32() // 32
Math.clz32(NaN) // 32
Math.clz32(Infinity) // 32
Math.clz32(null) // 32
Math.clz32('foo') // 32
Math.clz32([]) // 32
Math.clz32({}) // 32
Math.clz32(true) // 31

（5）Math.imul()返回两个数以 32 位带符号整数形式相乘的结果，返回的也是一个 32 位的带符号整数。对于那些很大的数的乘法，返回正确的低位数。
（6）Math.fround() 主要作用，是将64位双精度浮点数转为32位单精度浮点数。如果小数的精度超过24个二进制位，返回值就会不同于原值，否则返回值不变，对于 NaN 和 Infinity，此方法返回原值。对于其它类型的非数值，Math.fround 方法会先将其转为数值，再返回单精度浮点数。
（7）Math.hypot()返回所有参数的平方和的平方根。如果参数不是数值，Math.hypot方法会将其转为数值。只要有一个参数无法转为数值，就会返回 NaN。
（8）Math.expm1()：Math.expm1(x)返回 e^x - 1，即Math.exp(x) - 1。
（9）Math.log1p():Math.log1p(x)方法返回1 + x的自然对数，即Math.log(1 + x)。如果x小于-1，返回NaN。
（10）Math.log10()：Math.log10(x)返回以 10 为底的x的对数。如果x小于 0，则返回 NaN。
（11）Math.log2()：Math.log2(x)返回以 2 为底的x的对数。如果x小于 0，则返回 NaN。
（12）Math.sinh(x) 返回x的双曲正弦
（13）Math.cosh(x) 返回x的双曲余弦
（14）Math.tanh(x) 返回x的双曲正切
（15）Math.asinh(x) 返回x的反双曲正弦
（16）Math.acosh(x) 返回x的反双曲余弦
（17）Math.atanh(x) 返回x的反双曲正切

8.指数运算符

ES2016 新增了一个指数运算符（**），这个运算符的一个特点是右结合，而不是常见的左结合。多个指数运算符连用时，是从最右边开始计算的。

// 相当于 2 ** (3 ** 2)
2 ** 3 ** 2
// 512

let a = 1.5;
a **= 2;
// 等同于 a = a * a;
let b = 4;
b **= 3;
// 等同于 b = b * b * b;

9.BigInt 数据类型

（1）JavaScript 所有数字都保存成 64 位浮点数，这样存在两个限制，一是超过53位的二进制数会失去精度，二是超过2的1024的数值无法表示，因此引入BigInt（大整数）来解决问题，且没有位数限制。BigInt类型必须加后缀n，可以表示各种进制，BigInt与普通整数是两种值，并不相等。BigInt可以使用负号，但是不能使用正号。

const a = 2172141653n;
const b = 15346349309n;
// BigInt 可以保持精度
a * b // 33334444555566667777n
// 普通整数无法保持精度
Number(a) * Number(b) // 33334444555566670000

42n===42  //false

typeof 123n  // 'bigint'

-42n  //ture
+42n  //false

（2）BigInt对象
JavaScript原生提供BigInt对象，可以构造函数生成BigInt类型的数值，转换机制基本同Number（）一致，将其他类型的值转为BigInt。但其构造函数必有参数，且参数必须可以转为数值，小数也会报错。

BigInt(123) // 123n
BigInt('123') // 123n
BigInt(false) // 0n

new BigInt() // TypeError
BigInt(undefined) //TypeError
BigInt(null) // TypeError
BigInt('123n') // SyntaxError          字符串123n无法解析成Number类型
BigInt('abc') // SyntaxError
BigInt(1.5) // RangeError
BigInt('1.5') // SyntaxError

（3）转换规则
可以使用Boolean()、Number()和String()这三个方法，将 BigInt 可以转为布尔值、数值和字符串类型,取反运算符（!）也可以将 BigInt 转为布尔值。

Boolean(0n) // false
Boolean(1n) // true
Number(1n)  // 1
String(1n)  // "1"
!0n // true
!1n // false

（4）数学运算
BigInt 类型的+、-、*和**这四个二元运算符，与 Number 类型的行为一致。除法运算/会舍去小数部分，返回一个整数。两个除外(不带符号的右移运算符>>>和一元求正运算符+)。BigInt不能与普通数值混合运算。如果一个标准库函数的参数预期是 Number 类型，但是得到的是一个 BigInt，就会报错。
（5）其他运算
BigInt 对应的布尔值，与 Number 类型一致，即0n会转为false，其他值转为true。
比较运算符（比如>）和相等运算符（==）允许 BigInt 与其他类型的值混合计算，因为这样做不会损失精度。
BigInt 与字符串混合运算时，会先转为字符串，再进行运算。

数组的扩展

1.扩展运算符（…）

一个数组转为用逗号分隔的参数序列，可用于函数的调用，用于表达式，替代函数的 apply 方法，可以直接把数组转化为参数列表。

console.log(...[1, 2, 3])
// 1 2 3

function add(x, y) {
  return x + y;
}

const numbers = [4, 38];
add(...numbers) // 42

const x = 4;
const arr = [...(x>0?['a']:[]),'b'];
console.log(...arr);     //a b

let arr1 = [0, 1, 2];
let arr2 = [3, 4, 5];
arr1.push(...arr2);

应用
（1）复制数组
（2）合并数组
（3）与解构赋值结合
（4）字符串（把字符串转换为数组、扩展运算符可以正确识别四个字节的 Unicode 字符）
（5）实现了 Iterator 接口的对象
（6）Map 和 Set 结构，Generator 函数

2.Array.from()

Array.from方法用于将两类对象转为真正的数组：类似数组的对象和可遍历的对象。

let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

3.Array.of()

用于将一组值，转换为数组。Array.of基本上可以用来替代Array()或new Array()，并且不存在由于参数不同而导致的重载。它的行为非常统一。Array.of总是返回参数值组成的数组。如果没有参数，就返回一个空数组。

Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1
Array.of() // []
Array.of(undefined) // [undefined]
Array.of(1) // [1]
Array.of(1, 2) // [1, 2]

4.数组实例的copyWithin()

在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组。
接收的三个参数：
Array.prototype.copyWithin(target, start = 0, end = this.length)
target（必需）：从该位置开始替换数据。如果为负值，表示倒数。
start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示从末尾开始计算。
end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示从末尾开始计算。

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

// -2相当于3号位，-1相当于4号位
[1, 2, 3, 4, 5].copyWithin(0, -2, -1)
// [4, 2, 3, 4, 5]

5.数组实例的find()和findIndex()

（1）find()方法
用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。
（2）findIndex()方法
返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。

6.数组实例的fill()

fill()方法使用给定值，填充一个数组，接受第二个和第三个参数，用于指定填充的起始位置和结束位置。

 var a,b,c;
 console.log(['a','b','c'].fill(8));		//[8,8,8]

['a', 'b', 'c'].fill(7, 1, 2)

7.数组实例的entires(),keys(),values()

用于遍历数组。keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。

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"

8.数组实例的include()

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

[1, 2, 3].includes(2)     // true
[1, 2, 3].includes(4)     // false
[1, 2, NaN].includes(NaN) // true
[1, 2, 3].includes(3, 3);  // false
[1, 2, 3].includes(3, -1); // true

9.数组实例的flat()、flatMap()

（1）flat()
flat()用于将嵌套的数组“拉平”，变成一维的数组。该方法返回一个新数组，对原数据没有影响，flat()默认只会“拉平”一层，如果想要“拉平”多层的嵌套数组，可以将flat()方法的参数写成一个整数，表示想要拉平的层数，默认为1。如果不管有多少层嵌套，都要转成一维数组，可以用Infinity关键字作为参数。如果原数组有空位，flat()方法会跳过空位。

[1, 2, [3, 4]].flat()
// [1, 2, 3, 4]

[1, 2, [3, [4, 5]]].flat()
// [1, 2, 3, [4, 5]]

[1, 2, [3, [4, 5]]].flat(2)
// [1, 2, 3, 4, 5]

[1, [2, [3]]].flat(Infinity)
// [1, 2, 3]

[1, 2, , 4, 5].flat()
// [1, 2, 4, 5]

（2）flatMap()
对原数组的每个成员执行Array.prototype.map()，然后对返回值组成的数组执行flat()方法。该方法返回一个新数组，不改变原数组,flatMap()只能展开一层数组。

// 相当于 [[2, 4], [3, 6], [4, 8]].flat()
[2, 3, 4].flatMap((x) => [x, x * 2])
// [2, 4, 3, 6, 4, 8]

// 相当于 [[[2]], [[4]], [[6]], [[8]]].flat()
[1, 2, 3, 4].flatMap(x => [[x * 2]])
// [[2], [4], [6], [8]]

10.数组的空位

数组的某一个位置没有任何值。空位不是undefined，一个位置的值等于undefined，依然是有值的。空位是没有任何值。

Array(3) // [, , ,]
//Array(3)返回一个具有 3 个空位的数组。

Array.from方法会将数组的空位，转为undefined，也就是说，这个方法不会忽略空位。扩展运算符（…）也会将空位转为undefined。

Array.from(['a',,'b'])
// [ "a", undefined, "b" ]

[...['a',,'b']]
// [ "a", undefined, "b" ]

11.Array.prototype.sort()的排序稳定性

排序稳定性：是排序算法的重要属性，指的是排序关键字相同的项目，排序前后的顺序不变。

const arr = [
  'peach',
  'straw',
  'apple',
  'spork'
];

const stableSorting = (s1, s2) => {
  if (s1[0] < s2[0]) return -1;
  return 1;
};

arr.sort(stableSorting)
// ["apple", "peach", "straw", "spork"]
//排序结果是spork在straw前面，跟原始顺序相反，所以排序算法unstableSorting是不稳定的