一、 二进制和八进制表示法
- ES6 提供了二进制和八进制数值的新的写法,分别用前缀0b(或0B)和0o(或0O)表示。
0b111110111 === 503 // true
0o767 === 503 // true
- 如果要把以0b或0o为前缀的字符串数值转为十进制,使用Number()方法。
Number('0b111') // 7
Number('0o10') // 8
二、Number.isFinite(),Number.isNAN()
- Number.isFinite()用来检查一个数值是否为有限的(finite),即不是Infinity。如果参数类型不是数值,返回false。
Number.isFinite(15); // true
Number.isFinite(0.8); // true
Number.isFinite(NaN); // false
Number.isFinite(Infinity); // false
Number.isFinite(-Infinity); // false
Number.isFinite('foo'); // false
Number.isFinite('15'); // false
Number.isFinite(true); // false
- Number.isNaN()用来检查一个值是否为NaN。如果参数类型不是NaN,返回false。
Number.isNaN(NaN) // true
Number.isNaN(15) // false
Number.isNaN('15') // false
Number.isNaN(true) // false
Number.isNaN(9/NaN) // true
Number.isNaN('true' / 0) // true
Number.isNaN('true' / 'true') // true
三、Number.parseInt(),Number.parseFloat()
Number.parseInt、Number.parseFloat方法与parseInt、parseFloat方法一模一样,只是为了减少用全局方法,才让语言模块化。
alert( parseInt('12.34') ); //12
alert( parseFloat('23.232#') ); //23.232
四、Number.isInteger()
用于判断一个数字是不是整数。
alert( Number.isInteger(25) ); //true
//小数返回false
alert( Number.isInteger(25.3) ); //false
//25.0 === 25
alert( Number.isInteger(25.0) ); //true
//非数字返回false
alert( Number.isInteger(null) ); //false
- JS数值存储为64位双精度格式,数值精度最多可以达到 53 个二进制位(1 个隐藏位与 52 个有效位),所以当小数点后太多位可能会有错误出现,如:
Number.isInteger(3.0000000000000002) // true
- 如果一个数值的绝对值小于 5E-324,即小于js能够分辨的最小值,会被自动转为 0,此时也会误判。
Number.isInteger(5E-324) // false
Number.isInteger(5E-325) // true,值为0,是整数
五、Number.EPSILON
Number.EPSILON:表示 1 与大于 1 的最小浮点数之间的差。
引入一个这么小的量的目的,在于为浮点数计算,设置一个误差范围。我们知道浮点数计算是不精确的。
0.1 + 0.2
// 0.30000000000000004
0.1 + 0.2 - 0.3
// 5.551115123125783e-17
5.551115123125783e-17.toFixed(20)
// '0.00000000000000005551'
//因此0.1+0.2不绝对等于0.3
0.1 + 0.2 === 0.3; // false
Number.EPSILON可以用来设置“能够接受的误差范围”。如果两个浮点数的差小于这个值(Number.EPSILON * Math.pow(2, 2)),我们就认为这两个浮点数相等。
5.551115123125783e-17 < Number.EPSILON * Math.pow(2, 2)
// true
六、安全整数和Number.isSafeInteger()
- js能够准确表达的整数范围是-2^53~ 2 ^53之间(不包含端点),超过了这个范围就没有办法精准表示这个值。
//超出 2 的 53 次方之后,一个数就不精确了。
Math.pow(2, 53) === Math.pow(2, 53) + 1
// true
- ES6引入了Number.MAX_SAFE_INTEGER和Number.MIN_SAFE_INTEGER这两个常量,用来表示这个范围的上下限。
Number.MAX_SAFE_INTEGER === Math.pow(2, 53) - 1
// true
Number.MAX_SAFE_INTEGER === 9007199254740991
// true
Number.MIN_SAFE_INTEGER === -Number.MAX_SAFE_INTEGER
// true
Number.MIN_SAFE_INTEGER === -9007199254740991
// true
- Number.isSafeInteger()用来判断一个整数是否在这个范围之内。Number.MAX_SAFE_INTEGER和Number.MIN_SAFE_INTEGER用来精准的表示上下线。
Number.isSafeInteger('a') // false
Number.isSafeInteger(null) // false
Number.isSafeInteger(NaN) // false
Number.isSafeInteger(Infinity) // false
Number.isSafeInteger(-Infinity) // false
Number.isSafeInteger(3) // true
Number.isSafeInteger(1.2) // false
Number.isSafeInteger(9007199254740990) // true
Number.isSafeInteger(9007199254740992) // false
Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1) // false
Number.isSafeInteger(Number.MIN_SAFE_INTEGER) // true
Number.isSafeInteger(Number.MAX_SAFE_INTEGER) // true
Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1) // false
- 使用Number.isSafeInteger()函数时,如果里面的参数是表达式,则最好判断表达式内的每个值是否都是安全数。由于表达式的原因,如果式子内的结果不为安全数,但存储数据时已将其转化为安全数存储,此时再去调用该函数会返回true。
Number.isSafeInteger(9007199254740993)
// false
Number.isSafeInteger(990)
// true
Number.isSafeInteger(9007199254740993 - 990)
// true
9007199254740993 - 990
// 返回结果 9007199254740002
// 正确答案应该是 9007199254740003
七、Math对象的扩展
1、Math.trunc()
用法:用于去除一个数的小数部分。
(1)对于数字,直接保留整数部分
alert( Math.trunc(1.23) );
alert( Math.trunc(-1.23) );
alert( Math.trunc(0.23) );
alert( Math.trunc(-0.23) );
(2)对于非数字,直接转化成数值,再保留整数位
alert( Math.trunc("123.22") );
alert( Math.trunc(true) );
alert( Math.trunc(null) );
(3)对于空值和无法转换的值,会返回NaN
alert( Math.trunc(NaN) );
alert( Math.trunc() );
alert( Math.trunc(undefined) );
alert( Math.trunc("vygv") );
2、Math.sign()
用法:判断一个数到底是正数、负数、还是零。对于非数值,会先将其转换为数值。
参数为正数,返回+1;
参数为负数,返回-1;
参数为 0,返回0;
参数为-0,返回-0;
其他值,返回NaN。
(1)对于数值类型:
alert( Math.sign(5) ); //1
alert( Math.sign(-5) ); //-1
alert( Math.sign(0) ); //0
alert( Math.sign(-0) ); //0,没有返回-0
alert( Math.sign(NaN) ); //NaN
(2)对于非数值类型:
alert( Math.sign('') ); //0
alert( Math.sign() ); //NaN
alert( Math.sign(true) ); //1
alert( Math.sign(null) ); //0
alert( Math.sign('3') ); //1
alert( Math.sign("fnw") ); //NaN
alert( Math.sign(undefined) ); //NaN
3、Math.cbrt()
用法:用于计算一个数值的立方根。
(1)对于数值类型:
alert( Math.cbrt(1) ); //1
alert( Math.cbrt(-1) ); //-1
alert( Math.cbrt(0) ); //0
alert( Math.cbrt(2) ); //1.2599210498948732
(2)对于非数值类型,先转化为数值再计算:
alert( Math.cbrt() ); //NaN
alert( Math.cbrt("") ); //0
alert( Math.cbrt('27') ); //3
alert( Math.cbrt("fsfs") ); //NaN
alert( Math.cbrt(true) ); //1
alert( Math.cbrt(null) ); //0
alert( Math.cbrt(NaN) ); //NaN
alert( Math.cbrt(undefined) ); //NaN
4、Math.clz32()
用法:将参数转为 32 位无符号整数的形式(二进制形式下),然后返回这个 32 位值里面有多少个前导 0。
Math.clz32(0) // 32,0的二进制形式全为0,所以有32个0
Math.clz32(1) // 31,1的二进制形式只有一个1,所以有31个0
Math.clz32(1000) // 22
Math.clz32(0b01000000000000000000000000000000) // 1
Math.clz32(0b00100000000000000000000000000000) // 2
- 左移运算符与该方法直接相关
Math.clz32(0) // 32
Math.clz32(1) // 31
Math.clz32(1 << 1) // 30
Math.clz32(1 << 2) // 29
Math.clz32(1 << 29) // 2
- 对于小数,该方法只考虑整数部分
alert( Math.clz32(1.2) ); //31
- 对于非数值,会将其转换为数值,在调用该方法
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(a,b)
用法:返回两个数以 32 位带符号整数形式相乘的结果,返回的也是一个 32 位的带符号整数。
- 正常情况下,该方法返回的就是a*b,但是对于那些位数较大的数字,直接相乘可能会使结果不精确。
Math.imul(2, 4) // 8
Math.imul(-1, 8) // -8
//直接相乘不精确
(0x7fffffff * 0x7fffffff)|0 // 0
//调用该方法后返回正确结果
Math.imul(0x7fffffff, 0x7fffffff) // 1
6、Math.fround()
用法:返回一个数的32位单精度浮点数形式。
- 所以对于 -2 ^24 至 2 ^24 之间的整数(不含两个端点),返回结果与参数本身一致。
Math.fround(0) // 0
Math.fround(1) // 1
Math.fround(2 ** 24 - 1) // 16777215
- 若超出了这个精度范围,就开始丢失精度。
Math.fround(2 ** 24) // 16777216
Math.fround(2 ** 24 + 1) // 16777216
- 对于NaN 和 Infinity,此方法返回原值。对于其它类型的非数值,Math.fround 方法会先将其转为数值,再返回单精度浮点数。
Math.fround(NaN) // NaN
Math.fround(Infinity) // Infinity
Math.fround('5') // 5
Math.fround(true) // 1
Math.fround(null) // 0
Math.fround([]) // 0
Math.fround({}) // NaN
6、Math.hypot()
用法:返回所有参数的平方和的平方根。
- Math.hypot方法会将其转为数值。只要有一个参数无法转为数值,就会返回 NaN。
Math.hypot(3, 4); // 5
Math.hypot(3, 4, 5); // 7.0710678118654755
Math.hypot(); // 0
Math.hypot(NaN); // NaN
Math.hypot(3, 4, 'foo'); // NaN
Math.hypot(3, 4, '5'); // 7.0710678118654755
Math.hypot(-3); // 3
1、Math.expm1()
用法:Math.expm1(x)返回 ex - 1,即Math.exp(x) - 1。
Math.expm1(-1) // -0.6321205588285577
Math.expm1(0) // 0
Math.expm1(1) // 1.718281828459045
2、Math.log1p()
用法:返回1 + x的自然对数,即Math.log(1 + x)。如果x小于-1,返回NaN。
alert(Math.log1p(1)); //0.6931471805599453
3、Math.log10()
用法:返回以 10 为底的x的对数。如果x小于 0,则返回 NaN。
Math.log10(1) // 0
Math.log10(0) // -Infinity
Math.log10(10) //1
3、Math.log2()
用法:返回以 2 为底的x的对数。如果x小于 0,则返回 NaN。
Math.log2(2) // 1
Math.log2(1) // 0
Math.log2(0) // -Infinity
Math.sinh(x) 返回x的双曲正弦(hyperbolic sine)
Math.cosh(x) 返回x的双曲余弦(hyperbolic cosine)
Math.tanh(x) 返回x的双曲正切(hyperbolic tangent)
Math.asinh(x) 返回x的反双曲正弦(inverse hyperbolic sine)
Math.acosh(x) 返回x的反双曲余弦(inverse hyperbolic cosine)
Math.atanh(x) 返回x的反双曲正切(inverse hyperbolic tangent)
八、指数运算符
ES2016新增了指数运算符:**
2 ** 2 // 4
2 ** 3 // 8
该运算符从右向左结合。
alert(2**1**4); //2
(**=): 当**与=结合在一起时
let a = 1.5;
a **= 2;
// 等同于 a = a * a;
let b = 4;
b **= 3;
// 等同于 b = b * b * b;
九、BigInt数据类型
ES2020 引入了一种新的数据类型 BigInt(大整数)。BigInt 只用来表示整数,没有位数的限制,任何位数的整数都可以精确表示。
- 大整数必须加 n 在数字后
1234 // 普通整数
1234n // BigInt
// BigInt 的运算
alert(1n+3n); //4
- 大数值类型也可以用各种进制表示,但是都必须加上后缀n
0b1101n // 二进制
0o777n // 八进制
0xFFn // 十六进制
- 大整数和普通整数是两种值,所以它们并不相等
alert(11 === 11n); // false
- 大整数类型可以在数字前加 - 号,但是不能加 + 号
alert(-32n); //-32
alert(+23n); //报错
BigInt对象
js原生提供BigInt对象,用于把其他数据类型转化成BigInt类型。
alert(BigInt(123));
alert(BigInt('1234'));
alert(BigInt(true));
BigInt函数必须有参数,且参数必须能够转化为数值,否则会报错。
BigInt(undefined) //TypeError
BigInt(null) // TypeError
BigInt('123n') // SyntaxError
BigInt('abc') // SyntaxError
//如果是小数也会报错
BigInt(1.5) // RangeError
BigInt('1.5') // SyntaxError
转换规则
可以使用Boolean()、Number()和String()这三个方法,将 BigInt 转换成对应类型。
Boolean(0n) // false
Boolean(1n) // true
Number(1n) // 1
//转为字符串时n会消失
String(1n) // "1"
- 取反运算符(!)也可以将 BigInt 转为布尔值。
!0n // true
!1n // false
数学运算
BigInt 类型的+、-、*和**这四个二元运算符,与 Number 类型的行为一致。除法运算会直接舍去小数部分,返回一个整数。
9n / 5n // 1n
- BigInt 不能与普通数值进行混合运算。
1n + 1.3 // 报错,无论返回的是 BigInt 或 Number,都会导致丢失精度信息
其他运算
- BigInt 对应的布尔值,与 Number 类型一致,即0n会转为false,其他值转为true
if (0n) {
console.log(true);
} else {
console.log(false);
}
- 比较运算符(比如>)和相等运算符(==)允许 BigInt 与其他类型的值混合计算。
0n < 1 // true
0n < true // true
0n == 0 // true
0n == false // true
0n === 0 // false
- BigInt 与字符串混合运算时,会先转为字符串,再进行运算。
'' + 123n // "123"