数值的扩展、数组的扩展

谁借莪１个温暖的怀抱￠ 2022-12-14 13:36 153阅读 0赞

### 数值的扩展 ###

#### 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是不稳定的