js精确浮点数运算，处理浮点数运算中丢失精度问题

/**
 * @function js精确浮点数运算
 * @value 运算内容,必须为字符串，例如1+1,加引号'1+1'
 * @addSub 加法、减法
 * @mul 乘法
 * @div 除法
 */
const arithmetic = {
    filter(value) {
        if (!value) return null;
        let valueArr = value.split(/\-|\+|\*|\/|\(|\[|\)|\]|\^/g); //获取所有值集合
        //过滤空值、整数
        return {
            valueArr,
            floatValArr: valueArr.filter(item => {
                return item != '' && item.indexOf('.') >= 0;
            })
        }
    },
    addSub(value) {
        let {
            floatValArr,
            valueArr
        } = this.filter(value);
        //获取集合中浮点数最长的值
        let maxLen = 0;
        floatValArr.forEach(item => {
            let _arr = item.split('.');
            maxLen = _arr[1].length > maxLen ? _arr[1].length : maxLen;
        });
        if (maxLen == 0) return eval(value); //若没有浮点数，则正常运算
        let maxNum = '1'; //需要整除的数
        for(let i=0;i<maxLen;i++){
            maxNum+='0';
        }
        maxNum = Number(maxNum);
        //小数点前移，至浮点数最长的值长度
        valueArr = valueArr.forEach(item => {
            if (item != '') {
                value = value.replace(item, item * maxNum);
            }
        });
        return eval(value) / maxNum;
    },
    mul(value) {
        let {floatValArr} = this.filter(value);
        //获取集合中浮点数长度总和
        let maxLen = 0;
        floatValArr.forEach(item => {
            let _arr = item.split('.');
            maxLen += _arr[1].length;
            let multiple = '1';
            for (let i = 0; i < _arr[1].length; i++) {
                multiple += '0';
            }
            //小数点前移，至浮点数长度
            value = value.replace(item, item * multiple);
        });
        if (maxLen == 0) return eval(value); //若没有浮点数，则正常运算
        let maxNum = '1'; //需要整除的数
        for(let i=0;i<maxLen;i++){
            maxNum+='0';
        }
        maxNum = Number(maxNum);
        return eval(value) / maxNum;
    },
    div(value) {
        let {
            floatValArr,
            valueArr
        } = this.filter(value);
        //获取集合中浮点数最长的值
        let maxLen = 0;
        floatValArr.forEach(item => {
            let _arr = item.split('.');
            maxLen = _arr[1].length > maxLen ? _arr[1].length : maxLen;
        });
        if (maxLen == 0) return eval(value); //若没有浮点数，则正常运算
        let maxNum = '1'; //需要整除的数
        for(let i=0;i<maxLen;i++){
            maxNum+='0';
        }
        maxNum = Number(maxNum);
        //小数点前移，至浮点数最长的值长度
        valueArr = valueArr.forEach(item => {
            if (item != '') {
                value = value.replace(item, item * maxNum);
            }
        });
        return eval(value);
    }
}

实例：

0.1+0.2    //0.30000000000000004
1-0.9    //0.09999999999999998
0.1*0.2    //0.020000000000000004
arithmetic.addSub('0.1+0.2') // 0.3
arithmetic.addSub('1-0.9') //0.1
arithmetic.mul('0.1*0.2') //0.02