數值的擴充套件方法以及新增資料型別BigInt

fanction發表於2023-02-21
套件資料型別

二進位制和八進位製表示法

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喲

相關文章