ES6数值的扩展

一、 二进制和八进制表示法

  • 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"
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值