乐趣区

关于前端:数值的扩展方法以及新增数据类型BigInt

jiezi

二进制和八进制表示法

ES6提供了二进制和八进制数值的新的写法，别离用前缀 0b(或0B) 和0o或 (0O) 示意

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

在 es5 开始，严格模式中，八进制不容许应用前缀0 示意，否则会报错

// 严格模式
       (function(){console.log(0o11 === 011); // 报错
       })()
    // 非严格模式
      (function(){console.log(0o11 === 011); // true
        })()

如果要将 0b 和0o前缀的字符串数值转十进制，应用 Number 即可

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

数值分隔符

较长的数值容许增加分隔符，es2021容许 js 的数值应用下划线（_）作为分隔符

let num = 1_000_000_000
console.log(1000000000 === num);   // true

留神：分隔符并不影响原始值

分隔符没有距离位数的限度

let num2 = 1_00_0000_00
console.log(100000000 === num2);  // true

小数和迷信计数法也能够应用数值分隔符

console.log(0.00_01); // 0.0001
console.log(1e10_000); // Infinity

须要留神的是
1、_ 不能放在数值的最后面或最初面
2、_ 不能两个或以上的分隔符连在一起应用
3、_ 小数点的前后不能有分隔符
4、_ 迷信计数法中，示意指数的E 或e前后不能有分隔符

// 全副报错
3_.141
3._141
1_e12
1e_12
123__456
_1464301
1464301_

其它进制的数值也能够应用分隔符

console.log(0b1010_0001_1000_0101);  // 二进制
console.log(0xA0_B0_C0);  // 十六进制

留神：进制的前缀前后不能应用分隔符：0b、0B、0o、0O、0x、0X
不反对数值分隔符的函数：
1、Number()
2、parseInt()
3、parseFloat()

Number('123_456');  // NaN
parseInt('123_456');  // 123

Number.isFinite(), Number.isNaN()

Number.isFinite(): 用来查看一个数值是否为无限的, 即不是 Infinity
无限：true
非无限或非数值：false

Number.isFinite(10);  // true
Number.isFinite(1.2);  // true
Number.isFinite(NaN);  // false
Number.isFinite(Infinity);  // false
Number.isFinite('东方不败');  // false
Number.isFinite('123');  // false
Number.isFinite(true);  // false

Number.isNaN() : 用来查看一个值是否为NaN，如果参数不是NaN，返回false

Number.isNaN(NaN);  // true
Number.isNaN(10);  // false
Number.isNaN('10');  // false
Number.isNaN(true);  // false
Number.isNaN(9/NaN);  // true
Number.isNaN('东方不败' * 10);  // true
Number.isNaN(true / true);  // true

留神
它们与传统的全局办法 isFinite() 和isNaN()的区别在于，
传统办法先调用 Number() 将非数值的值转为数值，再进行判断，而这两个新办法只对数值无效。
Number.isFinite()对于非数值一律返回 false
Number.isNaN() 只有对于 NaN 才返回 true，非NaN 一律返回false

Number.parseInt(),Number.parseFloat()

ES5 : parseInt()、parseFloat()
ES6 : Number.parseInt()、Number.parseFloat()
行为齐全保持一致，这样做的目标是逐渐缩小全局性办法，使语言逐渐模块化

parseInt('12.55');  // 12
Number.parseInt('12.55');   // 12

parseFloat('12.55');  // 12.55
Number.parseFloat('12.55');   // 12.55

isInteger()

Number.isInteger()用来判断值是否为整数

Number.isInteger(15);  // true
Number.isInteger(15.1);  // false

如果值不是数值则返回false

Number.isInteger('15');  //false
Number.isInteger(true);  //false
Number.isInteger(NaN);  //false
Number.isInteger();  //false

JavaScript 采纳 IEEE 754 规范，数值存储为 64 位双精度格局，数值精度最多能够达到 53 个二进制位（1 个暗藏位与 52 个无效位）, 如果数值的精度超过这个限度，第 54 位及前面的位就会被抛弃，这种状况下，Number.isInteger 可能会误判。

Number.isInteger(3.0000000000000002) // true

下面代码中，Number.isInteger的参数明明不是整数，然而会返回 true，起因就是这个小数的精度达到了小数点后16 个十进制位，转成二进制位超过了 53 个二进制位，导致最初的那个 2 被抛弃了。
==!!!!! 总之，如果对数据精度的要求较高，不倡议应用 Number.isInteger()判断一个数值是否为整数。==

Math 对象的扩大

Math.trunc()

Math.trunc用于去掉数值的小数局部，返回整数局部

Math.trunc(5.1);  // 5
Math.trunc(5.5);  // 5
Math.trunc(-5.1); // -5
Math.trunc(-0.123);  // 0

对于非数值，会先应用 Number 办法将其转换为数值再返回

Math.trunc(true); // 1
Math.trunc(false); // 0
Math.trunc(null); // 0
Math.trunc('10.123'); // 10

对于空值或无奈转换的值，返回NaN

Math.trunc(NaN);  // NaN
Math.trunc('hello');  // NaN
Math.trunc();  // NaN

Math.sign()

Math.sign()办法用来判断一个数到底是负数、正数、还是零。非数值会先转换为数值

阐明 后果
参数为负数 +1
参数为正数 -1
参数未 0 0
参数为 -0 -0
其余 NaN 
Math.sign('5');  // 1
Math.sign(5); // 1
Math.sign(-5); // -1
Math.sign(0); // 0
Math.sign(-0); // -0
Math.sign(true); // 1
Math.sign('hello'); // NaN

Math.hypot()

Math.hypot()办法返回所有参数的平方和和平方根

Math.hypot(3,4);  // 5
Math.hypot(3,4,5); // 7.0710678118654755
Math.hypot(3,4,'5'); // 7.0710678118654755
Math.hypot(3,4,'hello'); // NaN
Math.hypot(); // 0

重点！

BigInt 数据类型

js的所有数字都保留成 64 位浮点数，这给数值的示意带来了很大的限度
一：数值的经度只能到 53 个二进制位，相当于 16 个十进制位，大于这个范畴的负数无奈准确示意, 使得 js 不适宜进行迷信和金融方面的准确计算。
二：大于等于 2 的1024次方的数值，js无奈示意，会返回Infinity。

// 超过 53 个二进制的数值们无奈放弃精度
Math.pow(2,53) === Math.pow(2,53) + 1;  // true
// 超过 2 的 1024 次方的数值，无奈示意
Math.pow(2,1024);  // Infinity

对此，ES2020引入了新的数据类型 BigInt(大整数），作为第八种数据类型，BigInt 只用来示意整数，没有位数限度，任何位数的整数都能够准确示意，语法：数据 n 

// 应用 BigInt
  let a = 2172141653n
  let b = 15346349309n
  console.log(a*b);  // 33334444555566667777n  // 能够放弃精度
// 一般数值
  let c = 2172141653
  let d = 15346349309
  console.log(c * d);  // 33334444555566670000 // 无奈放弃精度

与整数的区别

  • 123 一般整数
  • 123n BigInt
  • BigInt 类型的数据必须增加后缀n

BigInt与一般整数是两种值，它们之间并不相等

15n === 15; // false

数据类型返回bigint

typeof(15n); // bigint

BigInt 函数

BigInt能够用来做数据转换，转换的办法与 Number() 基本一致

BigInt(123);  // 123n
BigInt('123'); // 123n
BigInt(true); // 1n
BigInt(false); //0n

上面是 报错 的一些场景

BigInt();   //  TypeError
BigInt('hello');   //  SyntaxError

/* 字符串 123n 会无奈解析成 Number 类型，所以报错 */
BigInt('123n');   //  SyntaxError

BigInt(null);   //  TypeError
BigInt(NaN);   //  TypeError

/* 参数是小数也会报错 */
BigInt(1.2);   //  RangeError

BigInt('1.2');   //  SyntaxError

BigInt继承了 Object 对象的两个实例办法

  • BigInt.prototype.toString()
  • BigInt.prototype.valueOf()

它还继承了 Number 对象的一个实例办法

  • BigInt.prototype.toLocaleString()

此外还提供了三个静态方法

  • BigInt.asUintN(width, BigInt)
  • BigInt.asIntN(width, BigInt)
  • BigInt.parseInt(string[, radix])

BigInt 转换规则

能够应用 Boolean、Number、String 这三个办法，将BigInt 转换为布尔、数值、字符串类型，转换后，后缀 n 会隐没

Boolean(0n);  // false
Number(2n);  // 2
String(2n);  // '2'

取反 ! 运算符能够转换布尔值

console.log(!0n);  // true
console.log(!1n);  // false

BigInt 数学运算

在数学运算方面，+ - *和 ** 这四个运算符与 number 类型基本一致，除法运算 / 会舍去小数局部，返回一个整数

 console.log(9 / 5);  // 1.8
 console.log(9n / 5n);  // 1n  舍去小数

简直所有的数值运算符都能够用在 BigInt，然而有 两个例外。

  • 不带符号的右移位运算符>>>
  • 一元的求正运算符+

BigInt不能 与一般数值混合运算, 因为这样 精度会失落

console.log(2n + 5);  // TypeError

同样的起因，如果一个函数参数预期是 Number 类型，然而失去的是一个 BigInt 就会报错。

// 谬误的写法
Math.sqrt(4n) // 报错

// 正确的写法
Math.sqrt(Number(4n)) // 2

BigInt 其余运算

BigInt对应的布尔值，与 Number 类型统一

  • 0n : false
  • 1n : true
let n = 1n
if(n){console.log(true);
} else {console.log(false);
}  // true

比拟运算符和相等运算符容许 BigInt 与其余类型的值混合计算，因为这样做不会损失精度。

 console.log(0n < 1);  // true
 console.log(0n == false);  // true
 console.log(0n == 0);  // true
 console.log(0n === 0);  // false

案例源码：https://gitee.com/wang_fan_w/es6-science-institute

如果感觉这篇文章对你有帮忙，欢送点亮一下 star 哟

退出移动版