传入的类型判断

/**
 * 校验只要是数字（包含正负整数，0以及正负浮点数）就返回true
 */
export function isNumber (val) {
  var regPos = /^\d+(\.\d+)?$/ // 非负浮点数
  var regNeg =
    /^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$/ // 负浮点数
  if (regPos.test(val) || regNeg.test(val)) {
    return true
  } else {
    return false
  }
}

浮点数位数处理

/**
 * 浮点数位数处理，默认保留2位小数
 * @param {Number} f 需要处理的参数
 * @param {Number} digit 保留的小数点位数
 * @return {Number}
 */
export function decFloat (f, digit = 2) {
  if (isNumber(f)) {
    const m = Math.pow(10, digit)
    return parseInt(decMul(f, m, -1), 10) / m
  } else {
    return 0
  }
}

加法

/**
 * 加法
 * @param {Number} num1 加数
 * @param {Number} num2 加数
 * @param {Number} digit 保留位数，默认保留两位小数， 传入-1为高精度计算
 * @returns {Number} 返回相加后的结果
 */
export function decAdd (num1, num2, digit = 2) {
  if (isNumber(num1) && isNumber(num2)) {
    const num1Digits = (num1.toString().split('.')[1] || '').length
    const num2Digits = (num2.toString().split('.')[1] || '').length
    const baseNum = Math.pow(10, Math.max(num1Digits, num2Digits)) // 放大倍数baseNum是‘两个小数点后面长度这两者之间的最大值’
    const calcValue = (decMul(num1, baseNum) + decMul(num2, baseNum)) / baseNum
    if (digit === -1) {
      return calcValue
    } else {
      return decFloat(calcValue, digit)
    }
  } else {
    return 0
  }
}

减法

/**
 * 减法
 * @param {Number} num1 被减数
 * @param {Number} num2 减数
 * @param {Number} digit 保留位数，默认保留两位小数， 传入-1为高精度计算
 * @returns {Number} 返回相减后的结果
 */
export function decSub (num1 = 0, num2 = 0, digit = 2) {
  if (isNumber(num1) && isNumber(num2)) {
    const num1Digits = (num1.toString().split('.')[1] || '').length
    const num2Digits = (num2.toString().split('.')[1] || '').length
    const baseNum = Math.pow(10, Math.max(num1Digits, num2Digits)) // 放大倍数baseNum是‘两个小数点后面长度这两者之间的最大值’
    const calcValue = (decMul(num1, baseNum) - decMul(num2, baseNum)) / baseNum
    if (digit === -1) {
      return calcValue
    } else {
      return decFloat(calcValue, digit)
    }
  } else {
    return 0
  }
}

乘法

/**
 * 乘法
 * @param {Number} num1 乘数
 * @param {Number} num2 乘数
 * @param {Number} digit 保留位数，默认保留两位小数， 传入-1为高精度计算
 * @returns {Number} 返回相乘后的结果
 */
export function decMul (num1 = 0, num2 = 0, digit = 2) {
  if (isNumber(num1) && isNumber(num2)) {
    const num1String = num1.toString()
    const num2String = num2.toString()
    const num1Digits = (num1String.split('.')[1] || '').length
    const num2Digits = (num2String.split('.')[1] || '').length
    const baseNum = Math.pow(10, num1Digits + num2Digits) // 放大倍数baseNum是‘两个小数点后面长度之和’

    const calcValue =
      (Number(num1String.replace('.', '')) *
        Number(num2String.replace('.', ''))) /
      baseNum
    if (digit === -1) {
      return calcValue
    } else {
      return decFloat(calcValue, digit)
    }
  } else {
    return 0
  }
}

除法

/**
 * 除法
 * @param {Number} num1 被除数
 * @param {Number} num2 除数
 * @param {Number} digit 保留位数，默认保留两位小数， 传入-1为高精度计算
 * @returns {Number} 返回相除后的结果
 */
export function decDiv (num1 = 0, num2 = 0, digit = 2) {
  if (isNumber(num1) && isNumber(num2)) {
    const num1String = num1.toString()
    const num2String = num2.toString()
    const num1Digits = (num1String.split('.')[1] || '').length
    const num2Digits = (num2String.split('.')[1] || '').length
    const baseNum = Math.pow(10, num1Digits + num2Digits) // 放大倍数baseNum是‘两个小数点后面长度之和’
    let n1 = decMul(num1, baseNum)
    let n2 = decMul(num2, baseNum)

    const calcValue = Number(n1) / Number(n2)
    if (digit === -1) {
      return calcValue
    } else {
      return decFloat(calcValue, digit)
    }
  } else {
    return 0
  }
}