quality_frontend/packages/common/javascript/number.js

/**
 * @description: 将数字转化为字符串格式(添加逗号隔开)
 * @param {Number} 必选，需要添加逗号换算的数字
 * @return: {String} 数字添加了逗号的字符串
 */
export function numFormatToStr (data) {
 if (typeof data !== 'number') {
 return '0'
 }
 data = data || 0
 let negative = false
 if (data === 0) {
 return '0'
 }
 if (data < 0) {
 data *= -1
 negative = true
 }
 if (data) {
 let x1 = window.parseInt(data).toString()
 let len = x1.length
 let x2 = data.toString().slice(len)
 if (len <= 3) {
 return negative ? '-' + x1 + x2 : x1 + x2
 }
 let r = len % 3
 let b = x1.slice(r, len).match(/\d{3}/g).join(',')
 x1 = r > 0 ? x1.slice(0, r) + ',' + b : b
 let x = negative ? '-' + x1 + x2 : x1 + x2
 return x
 } else {
 return '0'
 }
}

/**
 * @description: 数值截取小数点后最多num位(不足num位，不补零)，非四舍五入
 * @param {Number} 必选
 * @param {Number} 可选，默认0
 * @return: {Number} 小数点位数截取后的数字
 */
export function sliceFloatNum (number, sliceNum) {
 if (typeof number !== 'number') {
 return 0
 }
 let numberStr = number.toString()
 let pointIndex = numberStr.indexOf('.')
 if (~pointIndex) {
 if (sliceNum) {
 number = numberStr.slice(0, pointIndex + sliceNum + 1)
 } else {
 number = numberStr.slice(0, pointIndex)
 }
 }
 return parseFloat(number)
}

/**
 * @description: 截取小数点后num位(若返回字符串，不足num位，则补零)，非四舍五入
 * @param {Number} 必选
 * @param {Number} 可选，默认2
 * @param {Boolean} 可选，是否转化为逗号分隔的字符串
 * @return: {Number | String} 小数点位数截取后的数字
 */
export function formatNum (data, sliceNum = 2, isFormatToStr = false) {
 if (!data || typeof data !== 'number') {
 return isFormatToStr ? '0' : 0
 }
 let negative = false
 if (data < 0) {
 negative = true
 data *= -1
 }
 let x1 = window.parseInt(data)
 let len = x1.toString().length
 data = sliceFloatNum(data, sliceNum)
 let x2 = data.toString().slice(len)
 let floatLength = sliceNum - x2.length
 if (~x2.indexOf('.')) {
 floatLength++
 }
 if (floatLength > 0) {
 if (!x2) { // 若数值为整数，不存在小数，则先添加小数点
 x2 = '.'
 }
 for (let i = 0; i < floatLength; i++) { // 小数点位数不足sliceNum位，则补零
 x2 += '0'
 }
 }
 if (isFormatToStr) { // 转化为字符串格式
 data = (negative ? '-' : '') + (numFormatToStr(x1) + x2)
 } else {
 data = parseFloat(x1 + x2)
 if (negative) {
 data *= -1
 }
 }
 return data
}

/**
 * @description: formatNum数组里的数字
 * @param {Array} 必选，数字数组
 * @param {Number} 可选，默认2
 * @param {Boolean} 可选，是否转化为逗号分隔的字符串
 * @return: {Array} 返回一个数组，数组里的数字均为小数点位数截取为指定位数
 */
export function formatNumArray (dataArray, num = 2, isFormatToStr = false) {
 if (!(dataArray instanceof Array)) { // 输入非数组，返回[]
 return []
 }
 let formatDataArray = []
 for (let key in dataArray) {
 formatDataArray[key] = formatNum(dataArray[key], num, isFormatToStr)
 }
 return formatDataArray
}

/**
 * @description: 返回小数点后的数字长度
 * @param {Number}
 * @return: {Number}
 */
function getDigitLength (num) {
 let r
 try {
 r = num.toString().split('.')[1].length
 } catch (e) {
 r = 0
 }
 return r
}

/**
 * @description: 解决js浮点数的加法精度错误
 * @param {Number} 必选，加数
 * @param {Number} 必选，被加数
 * @return: {Number} 返回两个数的和
 */
export function accuratePlus (num1, num2) {
 let r1 = getDigitLength(num1)
 let r2 = getDigitLength(num2)
 let m = Math.pow(10, Math.max(r1, r2))
 return Math.round(num1 * m + num2 * m) / m
}

/**
 * @description: 解决js浮点数的减法精度错误
 * @param {Number} 必选，减数
 * @param {Number} 必选，被减数
 * @return: {Number} 返回两个数的差
 */
export function accurateMinus (num1, num2) {
 let r1 = getDigitLength(num1)
 let r2 = getDigitLength(num2)
 let m = Math.pow(10, Math.max(r1, r2))
 return Math.round(num1 * m - num2 * m) / m
}

/**
 * @description: 解决js浮点数的乘法精度错误
 * @param {Number} 必选，乘数
 * @param {Number} 必选，被乘数
 * @return: {Number} 返回两个数的积
 */
export function accurateTimes (num1, num2) {
 let m = 0
 let s1 = num1.toString()
 let s2 = num2.toString()
 try {
 m += s1.split('.')[1].length
 } catch (e) {}
 try {
 m += s2.split('.')[1].length
 } catch (e) {}
 let r1 = Number(s1.replace('.', ''))
 let r2 = Number(s2.replace('.', ''))
 return (r1 * r2) / Math.pow(10, m)
}

/**
 * @description: 解决js浮点数的除法精度错误
 * @param {Number} 必选，除数
 * @param {Number} 必选，被除数
 * @return: {Number} 返回两个数的商
 */
export function accurateDivide (num1, num2) {
 let t1 = getDigitLength(num1)
 let t2 = getDigitLength(num2)
 let r1 = Number(num1.toString().replace('.', ''))
 let r2 = Number(num2.toString().replace('.', ''))
 return (r1 / r2) * Math.pow(10, t2 - t1)
}