整理自【阮一峰】数值的扩展:https://es6.ruanyifeng.com/#docs/number
文章目录
1.二进制和八进制表示法
从 ES5 开始,严格模式下,八进制不能使用 数字0 作前缀来表示。
ES6 明确,八进制要使用 数字0和字母o(大小写都可),即0o(0O)表示。
二进制要使用前缀 0b(或0B) 表示。
ES6中,要将 0b和0o前缀的字符串数值,转换为十进制,要使用 Number
方法。
Number(0B111) // 7
Number(0o10) // 8
2. Number.isFinite()和Number.isNaN()
-
Number.isFinite():检查一个数值是否为有限的(finite),即不是Infinity。
Number.isFinite(15) // true Number.isFinit(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.isFinite()
一律返回false
- 与传统 isFinite()的区别:
- Number.isFinite() 只对数值有效,非数值一律返回 false
- isFinite():先用 Number() 将非数值转换为数值,再判断。
- 如果参数类型不是
-
Number.isNaN():检查一个值是否为
NaN
-
Number.isNaN(NaN) // true Number.isNaN(1) // false Number.isNaN('1') // false Number.isNaN('NaN') // false Number.isNaN(9/NaN) // true Number.isNaN('true' / 0) // true Number.isNaN('true' / 'true') // true
-
如果参数不是
NaN
, Number.isNaN 一律返回false
-
与传统 isNaN()的区别:
-
Number.isNaN() 只对数值有效,非数值一律返回 false
-
isNaN():先用 Number() 将非数值转换为数值,再判断。
-
// isFinite isFinite(15) // true Number.isFinite(15) // true isFinite('15') // true Number.isFinite('15') // false // isNaN() isNaN(NaN) // true Number.isNaN(NaN) // true isNaN('NaN') // true Number.isNaN('NaN') // false Number.isNaN(1) // false ,不是 NaN
-
-
3. parseInt、parseFloat
-
Number.parseInt() === parseInt()
-
Number.parseFloat() === parseFloat()
-
ES6 将 parseInt 和 parseFloat 移植到 Number 对象上,行为完全保持不变。
- 原因:逐步减少全局性方法,使得语言逐步模块化。
4. Number.isInteger()
-
Number.isInteger() : 判断一个数值是否为
整数
。 -
由于 JavaScript 的 IEEE 754 标准,数值存储为 64位双精度格式,Number.isInteger() 存在误判的可能。
-
(1) 64位双精度格式:数值精度最多可达到 53 个二进制位(一个隐藏位和52个有效位)。如果数值的精度超过这个限度,第 54 位及后面的位就会被丢弃,从而导致数值不准的问题。
-
Number.isInteger(3.0000000000000002) // true
- 原因:这个数值的小数精度达到了,小数点后16个十进制位,转成二进制位超过了 53 个二进制位,导致最后的那个
2
被丢弃了。
- 原因:这个数值的小数精度达到了,小数点后16个十进制位,转成二进制位超过了 53 个二进制位,导致最后的那个
-
(2) 如果一个数值的绝对值小于 JavaScript 能分辨的最小值(Number.MIN_VALUE(5E-324)),会被自动转为 0 ,这时 Number.isInteger() 会误判。
-
Number.isInteger(5E-324) // false,不是整数 Number.isInteger(5E-325) // true, 误判成整数
- 原因:
5E-325
由于值太小,会被自动转为 0 ,因此返回 true。
- 原因:
-
-
如果对数据精度要求高,
不建议
使用Number.isInteger()
判断一个值是否为整数。
5.Number.EPSILON
-
Number.EPSILON : 一个极小的常量,表示 1 与大于 1 的最小浮点数之间的差。 ES6 在
Number
对象上新增的常量。- 实质:在 JavaScript 中,是一个可以接受的最小误差范围。
-
对 64 位浮点数来说,大于 1 的最小浮点数相当于二进制的1.0000000000000000000000000000000000000000000000000001,小数点后有连续 51 个零。这个值减去 1 后,就等于 2 的 -52次方。
-
Number.EPSILON // 2.220446049250313e-16 Math.pow(2,-52) // 2.220446049250313e-16 Number.EPSILON === Math.pow(2,-52) // true Number.EPSILON.toFixed(30) // "0.000000000000000222044604925031"
-
用途: 可以用来设置 “能够接受的误差范围” 。比如将误差范围设置在 2 的 -50 次方【
Number.EPSILON * Math.pow(2,2)
】,如果两个浮点数的差小于这个值,可认为此二者相等。 -
0.1 + 0.2 // 5.551115123125783e-17 5.551115123125783e-17 < Number.EPSILON * Math.pow(2,2) // true // 误差检查函数 function withinErrorMargin(left,right) { return Math.abs(left - right) < Number.EPSILON * Math.pow(2,2); } 0.1 + 0.2 === 0.3 // false withinErrorMargin(0.1+0.2, 0.3) // true 1.1+1.3 // 2.4000000000000004 withinErrorMargin(1.1+1.3, 2.4) // true
6.安全整数和 Number.isSafeInteger()
-
JavaScript 能准确表示的整数范围 在 2 53 ^{53 } 53 -到 2 − 53 ^{-53} −53 之间(不含两个 端点),超出范围无法精确表示这个值。
-
Number.MAX_SAFE_INTEGER:JavaScript 能准确表示的范围的 最大值。
-
Number.MIN_SAFE_INTEGER: JavaScript 能准确表示的范围的 最小值。
-
Number.isSafeInteger():用来判断一个整数是否在 JavaScript 能准确表示的这个范围内。
-
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(9007199254740990) // true Number.isSafeInteger(9007199254740992) // false,这个值是 2的53次方,端点值 Number.isSafeInteger(1.2) // false ,不是整数 Number.isSafeInteger(Number.MAX_SAFE_INTEGER) // true Number.isSafeInteger(Number.MIN_SAFE_INTEGER) // true Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1) // false Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1) // false // 最大安全整数 和 最小安全整数 Number.MAX_SAFE_INTEGER === Math.pow(2,53) - 1 // true Number.MAX_SAFE_INTEGER === 9007199254740991 // true Number.MIN_SAFE_INTEGER === -9007199254740991 // true Number.MAX_SAFE_INTEGER === -Number.MIN_SAFE_INTEGER // true
-
Number.isSafeInteger()的实现:
-
Number.isSafeInteger = function(n) { return (typeof n === 'number' && Math.round(n) === n && Math.MIN_SAFE_INTERGER <= n && n <= Number.MAX_SAFE_INTEGER); }
-
-
Number.isSafeInteger() 注意事项:
-
使用 Number.isSafeInteger()时,需要验证:
-
- 运算出的结果
- 参与运算的每个值。
-
-
Number.isSafeInteger(9007199254740993) // false,超出范围值 Number.isSafeInteger(990) // true Number.isSafeInteger(9007199254740993 - 990) // true 9007199254740993 - 990 // 得出的值:900754740002,实际值应为900754740003
-
9007199254740993
超出精度范围,导致计算机内部以9007199254740992
存储,从而出现计算结果错误。 -
可使用下面的函数验证 运算数 和 运算结果
-
// 简单判断函数 - 传 3 个参数进行判断 function simpleTrusty(left,right,result) { if ( Number.isSafeInteger(left) && Number.isSafeInteger(right) && Number.isSafeInteger(result) ) { return result; } throw new RangeError('Operation cannot be trusted!'); } // 较复杂判断函数 - 可传多个参数进行判断 function trusty() { let args = Array.prototype.slice.call(arguments) let result = args[args.length - 1] let isTrue = true; for (let ii = 0; ii < args.length-1 ;ii++) { let item = args [ii]; if(!Number.isSafeInteger(item)) { isTrue = false break } } if(isTrue) { return result } else { throw new RangeError('Operation cannot be trusted!') } } trusty(9007199254740991, 990, 9007199254740991 - 990) // 9007199254740001 trusty(9007199254740992, 990, 9007199254740992 - 990) // RangeError: Operation cannot be trusted! trusty(9007199254740991, 990, 1, 9007199254740991 - 990 - 1) // 9007199254740000
-
-
7. Math 对象的扩展
-
Math 新增的 17 个静态方法,只能在 Math 上使用:
-
1.
Math.trunc()
:用于去除一个数的小数部分,返回整数部分。参数为非数值时,内部先用Number
方法转为数值,再去除小数,返回整数部分;无法转换为数值的,返回NaN
。 -
2.
Math.sign()
:用于判断一个数是 正数、负数,还是 零。非数值先转成数值,无法转成数值的返回NaN
- 参数为正数:
+1
; - 参数为负数:
-1
; - 参数为 0 :
0
; - 参数为 -0:
-0
; - 其他值,返回
NaN
。
- 参数为正数:
-
3.
Math.cbrt()
:用于计算一个数的立方根
。参数为非数值时,内部先用Number
方法转为数值,无法转换为数值的,返回NaN
。 -
4.
Math.clz32()
:计算一个数的 32 位二进制形式的前导 0 的个数。将参数转为 32 位无符号整数的形式,返回这个 32 位值里面有多少个前导 0。-
clz32 : “count leading zero bits in 32-bite binary representation of a number”.(计算一个数的 32 位二进制形式的前导 0 的个数)
- 0 的二进制形式全为 0,所以有 32 个前导 0;
- 1 的二进制形式是
0b1
,只占 1 位,所以 32 位之中有 31 个前导 0; - 1000 的二进制形式是
0b1111101000
,一共有 10 位,所以 32 位之中有 22 个前导 0。
-
对于小数,
Math.clz32
方法只考虑整数部分。对于空值或其他类型的值,Math.clz32
方法会将它们先转为数值,然后再计算。Math.clz32(3.2) // 30 Math.clz32(3.9) // 30
-
-
5.
Math.imul()
:返回两个数以 32 位带符号整数形式相乘的结果,返回的也是一个 32 位的带符号整数。-
Math.imul(2, 4) // 8 Math.imul(-1, 8) // -8 Math.imul(-2, -2) // 4
如果只考虑最后 32 位,大多数情况下,
Math.imul(a, b)
与a * b
的结果是相同的,即该方法等同于(a * b)|0
的效果(超过 32 位的部分溢出)。之所以需要部署这个方法,是因为 JavaScript 有精度限制,超过 2 的 53 次方的值无法精确表示。这就是说,对于那些很大的数的乘法,低位数值往往都是不精确的,Math.imul
方法可以返回正确的低位数值。(0x7fffffff * 0x7fffffff)|0 // 0
上面这个乘法算式,返回结果为 0。但是由于这两个二进制数的最低位都是 1,所以这个结果肯定是不正确的,因为根据二进制乘法,计算结果的二进制最低位应该也是 1。这个错误就是因为它们的乘积超过了 2 的 53 次方,JavaScript 无法保存额外的精度,就把低位的值都变成了 0。
Math.imul
方法可以返回正确的值 1。Math.imul(0x7fffffff, 0x7fffffff) // 1
-
-
6.
Math.fround()
:返回一个数的32位单精度浮点数形式。对于NaN
和Infinity
,此方法返回原值。对于其它类型的非数值,Math.fround
方法会先将其转为数值,再返回单精度浮点数。-
主要作用:将64位双精度浮点数转为32位单精度浮点数。如果小数的精度超过24个二进制位,返回值就会不同于原值,否则返回值不变(即与64位双精度值一致)。
-
对于32位单精度格式来说,数值精度是24个二进制位(1 位隐藏位与 23 位有效位),所以对于 -2^24 至 2^24 之间的整数(不含两个端点),返回结果与参数本身一致。
Math.fround(0) // 0 Math.fround(1) // 1 Math.fround(2 ** 24 - 1) // 16777215
如果参数的绝对值大于 2 24 ^{24} 24,返回的结果便开始丢失精度。
Math.fround(2 ** 24) // 16777216 Math.fround(2 ** 24 + 1) // 16777216
// 未丢失有效精度 Math.fround(1.125) // 1.125 Math.fround(7.25) // 7.25 // 丢失精度 Math.fround(0.3) // 0.30000001192092896 Math.fround(0.7) // 0.699999988079071 Math.fround(1.0000000123) // 1
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
对于没有部署这个方法的环境,可以用下面的代码模拟。
Math.fround = Math.fround || function (x) { return new Float32Array([x])[0]; };
-
-
7.
Math.hypot()
:返回所有参数的平方和的平方根。-
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
-
上面代码中,3 的平方加上 4 的平方,等于 5 的平方。
如果参数不是数值,
Math.hypot
方法会将其转为数值。只要有一个参数无法转为数值,就会返回 NaN。
-
对数方法
-
8.
Math.expm1()
:Math.expm1(x)
返回 ex - 1,即Math.exp(x) - 1
。 -
9.
Math.log1p()
:Math.log1p(x)
方法返回1 + x
的自然对数,即Math.log(1 + x)
。如果x
小于-1,返回NaN
。 -
10.
Math.log10()
:Math.log10(x)
返回以 10 为底的x
的对数。如果x
小于 0,则返回 NaN。 -
11.
Math.log2()
:Math.log2(x)
返回以 2 为底的x
的对数。如果x
小于 0,则返回 NaN。
双曲函数方法
- 12.
Math.sinh(x)
: 返回x
的双曲正弦(hyperbolic sine) - 13.
Math.cosh(x)
:返回x
的双曲余弦(hyperbolic cosine) - 14.
Math.tanh(x)
:返回x
的双曲正切(hyperbolic tangent) - 15.
Math.asinh(x)
:返回x
的反双曲正弦(inverse hyperbolic sine) - 16.
Math.acosh(x)
:返回x
的反双曲余弦(inverse hyperbolic cosine) - 17.
Math.atanh(x)
:返回x
的反双曲正切(inverse hyperbolic tangent)
-
8.指数运算符
ES2016 新增了一个指数运算符(**
)。多个指数运算符连用时,是从最右边开始计算的。
2 ** 2 // 4
2 ** 3 // 8
这个运算符的一个特点是右结合,而不是常见的左结合。多个指数运算符连用时,是从最右边开始计算的。
// 相当于 2 ** (3 ** 2)
2 ** 3 ** 2
// 512
上面代码中,首先计算的是第二个指数运算符,而不是第一个。
指数运算符可以与等号结合,形成一个新的赋值运算符(**=
)。
let a = 1.5;
a **= 2;
// 等同于 a = a * a;
let b = 4;
b **= 3;
// 等同于 b = b * b * b;
9. BigInt 数据类型
简介
JavaScript 所有数字都保存成 64 位浮点数,这给数值的表示带来了两大限制。
一是数值的精度只能到 53 个二进制位(相当于 16 个十进制位),大于这个范围的整数,JavaScript 是无法精确表示的,这使得 JavaScript 不适合进行科学和金融方面的精确计算。
二是大于或等于2的1024次方的数值,JavaScript 无法表示,会返回Infinity
。
ES2020 引入了一种新的数据类型 BigInt(大整数),来解决这个问题,这是 ECMAScript 的 第八种数据类型
。BigInt 只用来表示整数,没有位数的限制,任何位数的整数都可以精确表示。
JavaScript数据类型
字符串(String)、
数字(Number)、
布尔(Boolean)、
数组(Array)、
对象(Object)、
空(Null)、
未定义(Undefined)、
大整数 (BigInt)。
BigInt 和 Number 的区别
-
BigInt 类型的数据,必须添加后缀 n,Number 不需要加后缀。
-
BigInt 能计算超出 JavaScript 精度范围的数据,Number 不能。如计算 70的阶乘(70!)
-
let p = 1; for (let i = 1; i <= 70; i++) { p *= i; } console.log(p); // 1.197857166996989e+100
let p = 1n; for (let i = 1n; i <= 70n; i++) { p *= i; } console.log(p); // 11978571669969891796072783721689098736458938142546425857555362864628009582789845319680000000000000000n
-
-
BigInt 类型数据,
只能
使用负号
(-
),不能使用 正号 (+
)(因为会与 asm.js冲突)。Number 类型可以使用负号
和正号
。 -
BigInt 类型的数据,在运算方面与 Number 几乎一致。只有两处不同,BigInt不能使用以下两种运算符:
- 不带符号的右移位运算符
>>>
,(BigInt 类型总是带符号,所以 >>> 运算无意义) - 一元的求正运算符
+
,(与asm.js冲突,为了不破坏 asm.js规定+1n
会报错)
- 不带符号的右移位运算符
-
BigInt 使用除法,会舍去小数部分,返回一个整数。Number 不会舍去小数部分,返回计算结果。
BigInt 类型的特点
-
BigInt 类型数据不等于 Number 类型数据。故,BigInt 和 Number 不能混合运算。
-
1n === 1 // 报错 ,1n 和 1 的数据类型不同,二者不相等 1n + 1.3 // 报错
-
-
BigInt 能表示各进制的值,都要加上后缀 n 。
-
0b1101n // 二进制 0o777n // 八进制 0xFFn // 十六进制
-
-
typeof
运算符对于 BigInt 类型的数据返回bigint
。 -
BigInt 类型只表示
整数
,不表示小数
,用 BigInt 表示小数会报错。 -
BigInt 能准确表示超出 JavaScript 精度范围的值。
BigInt 对象
JavaScript 原生提供BigInt
对象,可以用作构造函数生成 BigInt 类型的数值。转换规则基本与Number()
一致,将其他类型的值转为 BigInt。
BigInt(123) // 123n
BigInt('123') // 123n
BigInt(false) // 0n
BigInt(true) // 1n
BigInt()
构造函数必须有参数,而且参数必须可以正常转为数值,下面的用法都会报错。
new BigInt() // TypeError
BigInt(undefined) //TypeError
BigInt(null) // TypeError
BigInt('123n') // SyntaxError
BigInt('abc') // SyntaxError
上面代码中,尤其值得注意字符串123n
无法解析成 Number 类型,所以会报错。
参数如果是小数,也会报错。
BigInt(1.5) // RangeError
BigInt('1.5') // SyntaxError
BigInt 对象继承了 Object 对象的两个实例方法。
BigInt.prototype.toString()
BigInt.prototype.valueOf()
它还继承了 Number 对象的一个实例方法。
BigInt.prototype.toLocaleString()
此外,还提供了三个静态方法。
BigInt.asUintN(width, BigInt)
: 给定的 BigInt 转为 0 到 2 w i d t h ^{width } width- 1 之间对应的值。BigInt.asIntN(width, BigInt)
:给定的 BigInt 转为 -2width - 1 到 2 w i d t h ^{width } width - 1 - 1 之间对应的值。BigInt.parseInt(string[, radix])
:近似于Number.parseInt()
,将一个字符串转换成指定进制的 BigInt。
const max = 2n ** (64n - 1n) - 1n;
BigInt.asIntN(64, max)
// 9223372036854775807n
BigInt.asIntN(64, max + 1n)
// -9223372036854775808n
BigInt.asUintN(64, max + 1n)
// 9223372036854775808n
上面代码中,max
是64位带符号的 BigInt 所能表示的最大值。如果对这个值加1n
,BigInt.asIntN()
将会返回一个负值,因为这时新增的一位将被解释为符号位。而BigInt.asUintN()
方法由于不存在符号位,所以可以正确返回结果。
如果BigInt.asIntN()
和BigInt.asUintN()
指定的位数,小于数值本身的位数,那么头部的位将被舍弃。
const max = 2n ** (64n - 1n) - 1n;
BigInt.asIntN(32, max) // -1n
BigInt.asUintN(32, max) // 4294967295n
上面代码中,max
是一个64位的 BigInt,如果转为32位,前面的32位都会被舍弃。
下面是BigInt.parseInt()
的例子。
// Number.parseInt() 与 BigInt.parseInt() 的对比
Number.parseInt('9007199254740993', 10)
// 9007199254740992
BigInt.parseInt('9007199254740993', 10)
// 9007199254740993n
上面代码中,由于有效数字超出了最大限度,Number.parseInt
方法返回的结果是不精确的,而BigInt.parseInt
方法正确返回了对应的 BigInt。
对于二进制数组,BigInt 新增了两个类型BigUint64Array
和BigInt64Array
,这两种数据类型返回的都是64位 BigInt。DataView
对象的实例方法DataView.prototype.getBigInt64()
和DataView.prototype.getBigUint64()
,返回的也是 BigInt。
转换规则
可以使用Boolean()
、Number()
和String()
这三个方法,将 BigInt 可以转为布尔值、数值和字符串类型。
Boolean(0n) // false
Boolean(1n) // true
Number(1n) // 1
String(1n) // "1"
上面代码中,注意最后一个例子,转为字符串时后缀n
会消失。
另外,取反运算符(!
)也可以将 BigInt 转为布尔值。
!0n // true
!1n // false
数学运算
数学运算方面,BigInt 类型的+
、-
、*
和**
这四个二元运算符,与 Number 类型的行为一致。除法运算/
会舍去小数部分,返回一个整数。
9n / 5n
// 1n
几乎所有的数值运算符都可以用在 BigInt,但是有两个例外。
- 不带符号的右移位运算符
>>>
- 一元的求正运算符
+
上面两个运算符用在 BigInt 会报错。前者是因为>>>
运算符是不带符号的,但是 BigInt 总是带有符号的,导致该运算无意义,完全等同于右移运算符>>
。后者是因为一元运算符+
在 asm.js 里面总是返回 Number 类型,为了不破坏 asm.js 就规定+1n
会报错。
BigInt 不能与普通数值进行混合运算。
1n + 1.3 // 报错
上面代码报错是因为无论返回的是 BigInt 或 Number,都会导致丢失精度信息。比如(2n**53n + 1n) + 0.5
这个表达式,如果返回 BigInt 类型,0.5
这个小数部分会丢失;如果返回 Number 类型,有效精度只能保持 53 位,导致精度下降。
同样的原因,如果一个标准库函数的参数预期是 Number 类型,但是得到的是一个 BigInt,就会报错。
// 错误的写法
Math.sqrt(4n) // 报错
// 正确的写法
Math.sqrt(Number(4n)) // 2
上面代码中,Math.sqrt
的参数预期是 Number 类型,如果是 BigInt 就会报错,必须先用Number
方法转一下类型,才能进行计算。
asm.js 里面,|0
跟在一个数值的后面会返回一个32位整数。根据不能与 Number 类型混合运算的规则,BigInt 如果与|0
进行运算会报错。
1n | 0 // 报错
其他运算
BigInt 对应的布尔值,与 Number 类型一致,即0n
会转为false
,其他值转为true
。
if (0n) {
console.log('if');
} else {
console.log('else');
}
// else
上面代码中,0n
对应false
,所以会进入else
子句。
比较运算符(比如>
)和相等运算符(==
)允许 BigInt 与其他类型的值混合计算,因为这样做不会损失精度。
0n < 1 // true
0n < true // true
0n == 0 // true
0n == false // true
0n === 0 // false
BigInt 与字符串混合运算时,会先转为字符串,再进行运算。
'' + 123n // "123"
JavaScript 数据类型脑图(不包括 BigInt)
图片转载自 w3c school