谈一谈JS数字精度的问题

首先看一下JavaScript数字类型的说明，教科书上是这么说的，JS 遵循 IEEE 754 规范，采用双精度存储（double precision），占用 64 bit。如图

1是符号位，用来表示数字正负，11是

尾数位最大是 52 位，因此Javascript中能精准表示的最高整数是 Math.pow(2, 53) - 1，十进制即 9007199254740991（但Javascript可以表示的最大数是: 1.7976931348623157e+308，虽然可以表示，但存在精度丢失的问题）

那么超过最高整数会如何呢，让我们来看一下超过最高整数时精度的问题

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  未丢失精度

当超过最大精度时，因为二进制中储存尾数长度问题（最后一位被舍弃），精度就丢失了，让我们看看数字在二进制所表现的状态：

9007199254740992     >> 100000000000000000000000000000000000000000000000000000 //共计53个0
9007199254740992 + 1 >> 100000000000000000000000000000000000000000000000000001
9007199254740992 + 2 >> 100000000000000000000000000000000000000000000000000010
9007199254740992 + 3 >> 100000000000000000000000000000000000000000000000000011
9007199254740992 + 4 >> 100000000000000000000000000000000000000000000000000100

因为超出了储存长度，所以最末尾的1或0就被四舍五入了，故造成了精度丢失问题，所以会出现上面加双数精度没有丢失，加单数精度就会丢失的问题。

同理parseInt()也无法正常转换超过最高整数的字符串，均会被转为最高整数。

let strA = '9007199254740993'
parseInt(str) //输出9007199254740992

let strB = '9007199254740994'
parseInt(str) //输出9007199254740992

实际上Javascript可以直接查看最大和最小安全值

console.log(Number.MAX_SAFE_INTEGER) //9007199254740991
console.log(Number.MIN_SAFE_INTEGER) //-9007199254740991

一般来说在实际项目中很难需要去处理这么大的数字，如果只是传递用，那么可以转化为字符串来解决精度丢失问题。如果确实需要进行一些运算，那么还是推荐引用一些第三方库，如bignum之类的，这种类似的库还是很多的。

 

另一个是浮点数的问题，这个可能是会经常碰到的bug，先看一下代码：

console.log(0.1 + 0.2) //输出了 0.30000000000000004

console.log(0.7 + 0.1) //输出了 0.7999999999999999

console.log(0.3 - 0.2 == 0.1) //同样输出false

在金融领域要求严谨，也很容易出现这样的错误，这是浮点数精度带来的问题，这也可以通过上面说的一些库来解决。或者自己写个库也可以，网上也有很多例子了，我这里直接贴一份出来吧

/**
 * 精确加
 * @param arg1
 * @param arg2
 * @returns {number}
 */
Components.add = function (arg1, arg2) {
    var r1 = 0, r2 = 0, r3 = 0;
    try {
        r1 = (arg1 + '').split('.')[1].length;
    } catch (err) {
        r1 = 0;
    }
    try {
        r2 = (arg2 + '').split('.')[1].length;
    } catch (err) {
        r2 = 0;
    }
    r3 = Math.pow(10, Math.max(r1, r2));
    return (Components.mul(arg1, r3) + Components.mul(arg2, r3)) / r3;
};
/**
 * 精确减
 * @param arg1
 * @param arg2
 * @returns {number}
 */
Components.sub = function (arg1, arg2) {
    var r1 = 0, r2 = 0, r3 = 0;
    try {
        r1 = (arg1 + '').split('.')[1].length;
    } catch (err) {
        r1 = 0;
    }
    try {
        r2 = (arg2 + '').split('.')[1].length;
    } catch (err) {
        r2 = 0;
    }
    r3 = Math.pow(10, Math.max(r1, r2));
    return (Components.mul(arg1, r3) - Components.mul(arg2, r3)) / r3;
};
/**
 * 精确乘
 * @param arg1
 * @param arg2
 * @returns {number}
 */
Components.mul = function (arg1, arg2) {
    var r1 = arg1 + '', r2 = arg2 + '', r3 = 0, r4 = 0;
    try {
        r3 = r1.split('.')[1].length;
    } catch (err) {
        r3 = 0;
    }
    try {
        r4 = r2.split('.')[1].length;
    } catch (err) {
        r4 = 0;
    }
    return Number(r1.replace('.', '')) * Number(r2.replace('.', '')) / Math.pow(10, r4 + r3);
};
/**
 * 精确除
 * @param arg1
 * @param arg2
 * @returns {number}
 */
Components.div = function (arg1, arg2) {
    var r1 = arg1 + '', r2 = arg2 + '', r3 = 0, r4 = 0;
    try {
        r3 = r1.split('.')[1].length;
    } catch (err) {
        r3 = 0;
    }
    try {
        r4 = r2.split('.')[1].length;
    } catch (err) {
        r4 = 0;
    }
    return Components.mul((Number(r1.replace('.', '')) / Number(r2.replace('.', ''))), Math.pow(10, r4 - r3));
};
/**
 * 精确取余
 * @param arg1
 * @param arg2
 * @returns {number}
 */
Components.rem = function (arg1, arg2) {
    var r1 = 0, r2 = 0, r3 = 0;
    try {
        r1 = (arg1 + '').split('.')[1].length;
    } catch (err) {
        r1 = 0;
    }
    try {
        r2 = (arg2 + '').split('.')[1].length;
    } catch (err) {
        r2 = 0;
    }
    r3 = Math.pow(10, Math.max(r1, r2));
    return Components.mul(arg1, r3) % Components.mul(arg2, r3) / r3;
};
/**
 * 精确乘方
 * @param arg1
 * @param arg2
 * @returns {number}
 */
Components.pow = function (arg1, arg2) {
    var r1 = 0, r2 = 0;
    try {
        r1 = (arg1 + '').split('.')[1].length;
    } catch (err) {
        r1 = 0;
    }
    r2 = Math.pow(10, r1);
    return Math.pow(Components.mul(arg1, r2), arg2) / Math.pow(r2, arg2);
};
/**
 * 精确保留小数
 * @param arg1
 * @param dig 小数位数
 * @param flag 保留方式（-1：去尾；0：四舍五入；1：上位）
 * @returns {string}
 */
Components.fix = function (arg1, dig, flag) {
    dig = +dig > 0 ? +dig : 0;
    flag = Math.abs(flag) === 1 ? flag : 0;
    var r1 = Math.pow(10, dig), r2 = 0;
    if (flag === -1) r2 = Math.floor(Components.mul(arg1, r1)) / r1;
    if (flag === 0) r2 = Math.round(Components.mul(arg1, r1)) / r1;
    if (flag === 1) r2 = Math.ceil(Components.mul(arg1, r1)) / r1;
    return r2.toFixed(dig);
};