二進位制和八進位制表示法
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喲