JavaScript 内的数字没有 int(整数型) 与 float(浮点型) 之分,即 1
与 1.0
相同,为同一个数。
JavaScript 内所有数字都是浮点数,若遇到需要整数才能运算的情况,JavaScript 会自行将64位浮点数转成32位整数,再进行运算,而这个转换过程,便导致了精度丢失。
0.1 + 0.2
// 0.30000000000000004
0.1 + 0.7
// 0.7999999999999999
0.3 / 0.1
// 2.9999999999999996
(0.3 - 0.2) === (0.2 - 0.1)
// false
根据国际标准 IEEE 754,JavaScript 采用双精度存储(double precision),占用 64 bit。从最左边开始,是这样组成的:
计算机的二进制实现和位数限制有些数无法有限表示。就像一些无理数不能有限表示,如 圆周率 3.1415926…,1.3333… 等。
比如:
0.1 >> 0.0001 1001 1001 1001…(1001无限循环)
//Number(0.1).toString(2) === "0.0001100110011001100110011001100110011001100110011001101"
0.2 >> 0.0011 0011 0011 0011…(0011无限循环)
//Number(0.2).toString(2) === "0.001100110011001100110011001100110011001100110011001101"
此时只能模仿十进制进行四舍五入了,但是二进制只有 0 和 1 两个,于是变为 0 舍 1 入。这即是计算机中部分浮点数运算时出现误差,丢失精度的根本原因。
可以知道,看似有穷的数字, 在计算机的二进制表示里却是无穷的,由于存储位数限制因此存在“舍去”,精度丢失就发生了。
整数的精度丢失和浮点数本质上是一样的,尾数位最大是 52 位。
9007199254740992 >> 10000000000000...000 // 共计 53 个 0
9007199254740992 + 1 >> 10000000000000...001 // 中间 52 个 0
// 9007199254740992 + 1 = 9007199254740993
9007199254740992 + 2 >> 10000000000000...010 // 中间 51 个 0
// 9007199254740992 + 2 = 9007199254740994
实际上:
9007199254740992 + 1 >> 10000000000000...000 // 【丢失】
// 9007199254740992 + 1 = 9007199254740992 【丢失】
对于整数,前端出现问题的几率可能比较低,毕竟很少有业务需要需要用到超大整数,只要运算结果不超过 Math.pow(2, 53) 就不会丢失精度。
但对于小数,前端出现问题的几率还是很多的,尤其在一些电商网站涉及到金额等数据。
所以最主要的,还是解决浮点数精度丢失带来的问题。点击下滑到解决方案
精度最多只能到53个二进制位,这意味着,绝对值 小于 253 的整数,即 (-253, 253) 【开区间,不含】内的整数,都可以精确表示。
Math.pow(2, 53)
// 9007199254740992【未丢失】
Math.pow(2, 53) + 1
// 9007199254740992【丢失】
Math.pow(2, 53) + 2
// 9007199254740994【未丢失】
Math.pow(2, 53) + 3
// 9007199254740996【丢失】
Math.pow(2, 53) + 4
// 9007199254740996【未丢失】
// etc...
由于 253 是一个16位的十进制数值,所以简单的法则就是,JavaScript 对15位的十进制数都可以精确处理。
一个安全整数是一个符合下面条件的整数:
比如,253 - 1 是一个安全整数,它能被精确表示,在任何 IEEE-754 舍入模式(rounding mode)下,没有其他整数舍入结果为该整数。作为对比,253 就不是一个安全整数,它能够使用 IEEE-754 表示,但是 253 + 1 不能使用 IEEE-754 直接表示,在就近舍入(round-to-nearest)和向零舍入中,会被舍入为 253。
// 即:由于在 js 中,Math.pow(2, 53) 存在与它相等的另一个值 "Math.pow(2, 53) + 1",并不安全。所以不属于安全整数。
Math.pow(2, 53) === 9007199254740992 // 未丢失
Math.pow(2, 53) + 1 === 9007199254740992 // 丢失
安全整数范围为 “-(253 - 1)” 到 “253 - 1” 之间的整数,包含 -(253 - 1) 和 253 - 1。
利用 isSafeInteger()
方法来判断一个值是否为安全整数:(IE 不兼容)
Number.isSafeInteger(3); // true
Number.isSafeInteger(Math.pow(2, 53)) // false
Number.isSafeInteger(Math.pow(2, 53) - 1) // true
Number.isSafeInteger(NaN); // false
Number.isSafeInteger(Infinity); // false
Number.isSafeInteger("3"); // false
Number.isSafeInteger(3.1); // false
Number.isSafeInteger(3.0); // true
【注意:IE 不支持 MIN_SAFE_INTEGER 和 MAX_SAFE_INTEGER,这两个常量是 ES6 引入的,在此之前只能作为事实标准。】
Number.MIN_SAFE_INTEGER
常量,表示在 JavaScript中最小的安全整数 “-(253 - 1)”。值为 -9007199254740991。
Number.MAX_SAFE_INTEGER
常量,表示在 JavaScript 中最大的安全整数 “253 - 1”。值为 9007199254740991。
Number.MIN_SAFE_INTEGER === -(Math.pow(2, 53) - 1);
// true
Number.MAX_SAFE_INTEGER === Math.pow(2, 53) - 1;
// true
根据 IEEE 754 标准,64位浮点数的指数部分的长度是11个二进制位,意味着指数部分的最大值是2047(211-1 = 2047)。分出一半表示正数,一半表示负数,则 JavaScript 能够表示的数值范围为 (21024, 2-1023) 【开区间,不含】,超出这个范围的数无法表示。
// 正向溢出
Math.pow(2, 1024) // Infinity【正数数值非常大,无法表示,正向溢出,只能返回正无穷】
// 负向溢出
Math.pow(2, -1075) // 0【正数数值非常小,无法表示,负向溢出,返回 0】
Number.MAX_VALUE // 1.7976931348623157e+308
// 正数最接近正无穷的值,再大就会返回正无穷
Number.MIN_VALUE // 5e-324
// 正数最接近零的值,再小就会返回 0
Number.MAX_VALUE < Math.pow(2, 1024)
// true
Number.MAX_VALUE > Math.pow(2, 1024)
// false
Number.MIN_VALUE > Math.pow(2, -1075)
// true
Number.MIN_VALUE < Math.pow(2, -1075)
// false
MAX_VALUE
比 Math.pow(2, 1024)
更具体些。值可以等于 MAX_VALUE 而不会返回 “Infinity”,但等于 Math.pow(2, 1024) 则会返回 “Infinity”。
MIN_VALUE
比 Math.pow(2, -1075)
更具体些。值可以等于 MIN_VALUE 而不会返回 “0”,但等于 Math.pow(2, -1075) 则会返回 “0”。
示例:
// 当两数乘积小于或等于 MAX_VALUE 时,调用 func1(),否则调用 func2();
if (num1 * num2 <= Number.MAX_VALUE) {
// 在可正常表示范围内
func1();
} else {
// 正向溢出,返回 Infinity
func2();
}
// 当两个数相除大于或等于 MIN_VALUE 时,调用 func1(),否则调用 func2();
if (num1 / num2 >= Number.MIN_VALUE) {
// 在可正常表示范围内
func1();
} else {
// 负向溢出,返回 0
func2();
}
Number.MAX_VALUE + 1 !== Infinity
IEEE 754 标准规定:只有大于等于 1.7976931348623158e+308
的数才会被 round 到 “Infinity”。而 Number.MAX_VALUE 才 1.7976931348623157e+308
,加上 1 还远远不到 Infinity。
这个数比 Number.MAX_VALUE 大 (254 - 1) * 2970 - (253 - 1) * 2971 = 2970
。
但 IEEE754 能表示的精度有限,事实上有无数个 2970 附近的数被表示成了 2970,更准确的说,应该是:
要让 Number.MAX_VALUE 变成 “Infinity”,至少要加上一个被 IEEE754 四舍五入为 2970 的数。
ECMA 给出的解决方法是:将浮点数分别乘 10n 转为整数,再除以 10n。但却并不怎么实用。
比如:((0.01 * 100) + (0.02 * 100)) / 100 === 0.03;
以下是我在网络上找到的比较好的两个解决方案。
【注意:转换后的整数依然不能超过 9007199254740992。】
// 来源:https://www.cnblogs.com/snandy/p/4943138.html
/**
* floatObj 包含加减乘除四个方法,能确保浮点数运算不丢失精度
*
* 我们知道计算机编程语言里浮点数计算会存在精度丢失问题(或称舍入误差),其根本原因是二进制和实现位数限制有些数无法有限表示
* 以下是十进制小数对应的二进制表示
* 0.1 >> 0.0001 1001 1001 1001…(1001无限循环)
* 0.2 >> 0.0011 0011 0011 0011…(0011无限循环)
* 计算机里每种数据类型的存储是一个有限宽度,比如 JavaScript 使用 64 位存储数字类型,因此超出的会舍去。舍去的部分就是精度丢失的部分。
*
* ** method **
* add / subtract / multiply /divide
*
* ** explame **
* 0.1 + 0.2 == 0.30000000000000004 (多了 0.00000000000004)
* 0.2 + 0.4 == 0.6000000000000001 (多了 0.0000000000001)
* 19.9 * 100 == 1989.9999999999998 (少了 0.0000000000002)
*
* floatObj.add(0.1, 0.2) >> 0.3
* floatObj.multiply(19.9, 100) >> 1990
*
*/
var floatObj = function() {
/*
* 判断obj是否为一个整数
*/
function isInteger(obj) {
return Math.floor(obj) === obj
}
/*
* 将一个浮点数转成整数,返回整数和倍数。如 3.14 >> 314,倍数是 100
* @param floatNum {number} 小数
* @return {object}
* {times:100, num: 314}
*/
function toInteger(floatNum) {
// 初始化对象, times:10 的次方,num:去除小数点后返回的整数
var ret = {
times: 1, num: 0};
var isNegative = floatNum < 0;
// 若该浮点数是整数,则直接返回
if (isInteger(floatNum)) {
ret.num = floatNum;
return ret;
}
// 转为字符串类型,再检测小数点
var strfi = floatNum + '';
var dotPos = strfi.indexOf('.');
// 提取小数点后的数字,并获取长度,作为 10 的幂
var len = strfi.substr(dotPos+1).length;
// 浮点数转为整数后的倍数(几个小数位就几个次方)
var times = Math.pow(10, len)
// 获取整数绝对值,parseInt() 方法不会对小数点及后面的数字进行转换,而加 0.5 是为了进行四舍五入
var intNum = parseInt(Math.abs(floatNum) * times + 0.5, 10);
// 浮点数为负数
if (isNegative) {
intNum = -intNum;
}
// 对象赋值
ret.times = times;
ret.num = intNum;
// 返回对象
return ret;
}
/*
* 核心方法,实现加减乘除运算,确保不丢失精度
* 思路:把小数放大为整数(乘),进行算术运算,再缩小为小数(除)
*
* @param a {number} 运算数1
* @param b {number} 运算数2
* @param digits {number} 精度,保留的小数点数,比如 2, 即保留为两位小数
* @param op {string} 运算类型,有加减乘除(add/subtract/multiply/divide)
*
*/
function operation(a, b, digits, op) {
// 将浮点数转为整数,返回对象
var o1 = toInteger(a);
var o2 = toInteger(b);
// 获取转换后的整数与小数位
var n1 = o1.num;
var n2 = o2.num;
var t1 = o1.times;
var t2 = o2.times;
// 判断两个小数位大小
var max = t1 > t2 ? t1 : t2;
// 初始化变量
var result = null;
switch (op) {
// 加
case 'add':
if (t1 === t2) {
// 两个小数位数相同
result = n1 + n2;
} else if (t1 > t2) {
// o1 小数位 大于 o2
result = n1 + n2 * (t1 / t2);
} else {
// o1 小数位 小于 o2
result = n1 * (t2 / t1) + n2;
}
return result / max;
// 减
case 'subtract':
if (t1 === t2) {
result = n1 - n2;
} else if (t1 > t2) {
result = n1 - n2 * (t1 / t2);
} else {
result = n1 * (t2 / t1) - n2;
}
return result / max;
// 乘
case 'multiply':
result = (n1 * n2) / (t1 * t2);
return result;
// 除
case 'divide':
result = (n1 / n2) * (t2 / t1);
return result;
}
}
// 加减乘除的四个接口
function add(a, b, digits) {
return operation(a, b, digits, 'add');
}
function subtract(a, b, digits) {
return operation(a, b, digits, 'subtract');
}
function multiply(a, b, digits) {
return operation(a, b, digits, 'multiply');
}
function divide(a, b, digits) {
return operation(a, b, digits, 'divide');
}
// exports
return {
add: add,
subtract: subtract,
multiply: multiply,
divide: divide
}
}();
// toFixed 修复【解决 chrome 浏览器中,toFixed() 四舍五入不准的问题,但浏览器早已修复】
function toFixed(num, s) {
var times = Math.pow(10, s);
var des = num * times + 0.5;
des = parseInt(des, 10) / times;
return des + '';
}
// 来源:https://www.iteye.com/blog/talentluke-1767138
// 两个浮点数求和
function accAdd(num1, num2) {
var r1, r2, m;
try {
r1 = num1.toString().split('.')[1].length;
} catch(e) {
r1 = 0;
}
try {
r2 = num2.toString().split(".")[1].length;
} catch(e) {
r2 = 0;
}
m = Math.pow(10,Math.max(r1,r2));
// return (num1*m+num2*m)/m;
return Math.round(num1*m+num2*m)/m;
}
// 两个浮点数相减
function accSub(num1, num2) {
var r1, r2, m;
try {
r1 = num1.toString().split('.')[1].length;
} catch(e) {
r1 = 0;
}
try {
r2 = num2.toString().split(".")[1].length;
} catch(e) {
r2 = 0;
}
m = Math.pow(10,Math.max(r1,r2));
n = (r1 >= r2) ? r1 : r2;
return Number((Math.round(num1*m-num2*m)/m).toFixed(n));
}
// 两个浮点数相除
function accDiv(num1, num2) {
var t1, t2, r1, r2;
try {
t1 = num1.toString().split('.')[1].length;
} catch(e) {
t1 = 0;
}
try {
t2 = num2.toString().split(".")[1].length;
} catch(e) {
t2 = 0;
}
r1 = Number(num1.toString().replace(".",""));
r2 = Number(num2.toString().replace(".",""));
return (r1/r2)*Math.pow(10,t2-t1);
}
// 两个浮点数相乘
function accMul(num1, num2) {
var m = 0, s1 = num1.toString(), s2 = num2.toString();
try {
m+=s1.split(".")[1].length} catch(e) {
};
try {
m+=s2.split(".")[1].length} catch(e) {
};
return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m);
}