js做四舍五入运算时，精度丢失问题

/**
 * 解决两个数相加精度丢失问题
 * @param a
 * @param b
 * @returns {Number}
 */
 floatAdd(a, b) {
    let c = 0
    let d = 0
    let e = 0
    if(undefined==a||null==a||""==a||isNaN(a)){a=0;}
    if(undefined==b||null==b||""==b||isNaN(b)){b=0;}
    try {
        c = a.toString().split(".")[1].length;
    } catch (f) {
        c = 0;
    }
    try {
        d = b.toString().split(".")[1].length;
    } catch (f) {
        d = 0;
    }
    e = Math.pow(10, Math.max(c, d));
    const result = (floatMul(a, e) + floatMul(b, e)) / e;
    return this.roundFloat (result)
}
/**
 * 解决两个数相减精度丢失问题
 * @param a
 * @param b
 * @returns {Number}
 */
floatSub(a, b) {
    let c = 0
    let d = 0
    let e = 0
    if(undefined==a||null==a||""==a||isNaN(a)){a=0;}
    if(undefined==b||null==b||""==b||isNaN(b)){b=0;}
    try {
        c = a.toString().split(".")[1].length;
    } catch (f) {
        c = 0;
    }
    try {
        d = b.toString().split(".")[1].length;
    } catch (f) {
        d = 0;
    }
    e = Math.pow(10, Math.max(c, d));
    const result = (floatMul(a, e) - floatMul(b, e)) / e;
    return this.roundFloat (result)
}
/**
 * 解决两个数相乘精度丢失问题
 * @param a
 * @param b
 * @returns {Number}
 */
floatMul(a, b) {
    let c = 0,
    let d = a.toString(),
    let e = b.toString();
    try {
        c += d.split(".")[1].length;
    } catch (f) {}
    try {
        c += e.split(".")[1].length;
    } catch (f) {}
    const result = Number(d.replace(".", "")) * Number(e.replace(".", "")) / Math.pow(10, c);
    return this.roundFloat (result)
}
/**
 * 解决两个数相除精度丢失问题
 * @param a
 * @param b
 * @returns
 */
function floatDiv(a, b) {
    let c = 0
    let d = 0
    let e = 0
    let f = 0
    try {
        e = a.toString().split(".")[1].length;
    } catch (g) {}
    try {
        f = b.toString().split(".")[1].length;
    } catch (g) {}
    c = Number(a.toString().replace(".", ""))
    d = Number(b.toString().replace(".", ""))
    const result = floatMul(c / d, Math.pow(10, f - e));
    return this.roundFloat (result)
}
/**

* 加法/减法运算（四舍五入的时候，不需要这个方法）

* 减法时，第二个参数为负值即可

* @param {Number} arg1 - 加数/减数

* @param {Number} arg2 - 加数/被减数

*/

addFloat(arg1, arg2) {

let m = 0; // 记录两个加数中最长的小数位长度

let arg1Str = arg1 + '';

let arg2Str = arg2 + '';

const arg1StrFloat = arg1Str.split('.')[1];

const arg2StrFloat = arg2Str.split('.')[1];

arg1StrFloat && (m = arg1StrFloat.length);

arg2StrFloat && (m = m > arg2StrFloat.length ? m : arg2StrFloat.length);

arg1Str = arg1.toFixed(m); // 补零

arg2Str = arg2.toFixed(m);

const transferResult = +(arg1Str.replace('.', '')) + +(arg2Str.replace('.', ''));

return transferResult / Math.pow(10, m);

};

// 乘法运算

multiplyFloat(arg1, arg2) {

let m = 0;

const arg1Str = arg1 + ''; const arg2Str = arg2 + '';

const arg1StrFloat = arg1Str.split('.')[1];

const arg2StrFloat = arg2Str.split('.')[1];

arg1StrFloat && (m += arg1StrFloat.length);

arg2StrFloat && (m += arg2StrFloat.length);

const transferResult = +(arg1Str.replace('.', '')) * +(arg2Str.replace('.', ''));

return transferResult / Math.pow(10, m)

};

/**

* 除法运算

* @param {Number} arg1 - 参数1除数

* @param {Number} arg2 - 参数2被除数

*/

divideFloat(arg1, arg2) {

const arg1Str = arg1 + '';

const arg2Str = arg2 + '';

const arg1StrFloat = arg1Str.split('.')[1] || '';

const arg2StrFloat = arg2Str.split('.')[1] || '';

const m = arg2StrFloat.length - arg1StrFloat.length;

const transferResult = +(arg1Str.replace('.', '')) / +(arg2Str.replace('.', ''));

return transferResult * Math.pow(10, m);

};

// 四舍五入解决精度丢失的问题 decimal 为 保留的小数位数，默认为2

roundFloat (value, decimal = 2) {
    const n = Math.pow(10, decimal);
    return divideFloat(Math.round(multiplyFloat(value, n)), n)
}