一、精度问题
在使用 js 计算加减乘除时，容易出现精度问题。如
// 加法 =====================
0.1 + 0.2 = 0.30000000000000004
0.7 + 0.1 = 0.7999999999999999
0.2 + 0.4 = 0.6000000000000001
// 减法 =====================
1.5 - 1.2 = 0.30000000000000004
0.3 - 0.2 = 0.09999999999999998
// 乘法 =====================
19.9 * 100 = 1989.9999999999998
0.8 * 3 = 2.4000000000000004
35.41 * 100 = 3540.9999999999995
// 除法 =====================
0.3 / 0.1 = 2.9999999999999996
0.69 / 10 = 0.06899999999999999
1.1 为什么会出现精度的损失
还要从浮点数的存储说起：
1.1.1 浮点数的存储
JS 中所有数字，包括整数和小数，只有一种类型，那就是 Number。 其实现遵循 IEEE 754 标准，使用 64 位固定长度表示，即 double 双精度浮点数。
64 位比特可分为三部分：
-
符号位 S：第 1 位是正负数符号位（sign），0 代表正数，1 代表负数
-
指数位 E：中间的 11 位存储指数（exponent），用来表示次方数
-
尾数位 M：最后的 52 位是尾数（mantissa），超出的部分自动进一舍零
1.1.2 浮点数的运算
JS 在计算 0.1 + 0.2 时到底发生了什么？
- 十进制的 0.1 和 0.2 会被转换成二进制的，但是由于浮点数用二进制表示时是无穷的：
0.1 -> 0.0001 1001 1001 1001...(1100循环)
0.2 -> 0.0011 0011 0011 0011...(0011循环)
- 64 位双精度浮点数的小数部分最多支持 53 位二进制位，所以两者相加之后得到二进制为：
0.0100110011001100110011001100110011001100110011001100
- 因浮点数小数位的限制而截断的二进制数字，再转换为十进制，就成了 0.30000000000000004
这也就是在计算时会产生误差。
1.2 如何解决精度问题
1.2.1 toFixed 的不完美
toFixed()方法可把 Number 四舍五入为指定小数位数的数字，但有时在不同浏览器下测试结果不同，如下面是在 chrome 下：
1.35.toFixed(1) // 1.4 正确
1.335.toFixed(2) // 1.33 错误
1.3335.toFixed(3) // 1.333 错误
1.33335.toFixed(4) // 1.3334 正确
1.333335.toFixed(5) // 1.33333 错误
1.3333335.toFixed(6) // 1.333333 错误
而在 IE 下面则是正确的。
1.2.2 人为矫正
1.2.2.1 将计算的数字升级
0.1 + 0.2 == 0.3 //false
(0.1*10 + 0.2*10)/10 == 0.3 //true
但有可能翻车：
35.41 * 100 = 3540.9999999999995
1.2.2.2 记录小数位长度
思路： 将浮点数 toString 后 indexOf(‘.’)，记录一下小数位的长度，然后将小数点抹掉
完整代码：
/*** method **
* add / subtract / multiply /divide
* floatObj.add(0.1, 0.2) >> 0.3
* floatObj.multiply(19.9, 100) >> 1990
*
*/
var floatObj = function() {
/*
* 判断obj是否为一个整数
*/
function isInteger(obj) {
return Math.floor(obj) === obj
}
/*
* 将一个浮点数转成整数，返回整数和倍数。如 3.14 >> 314，倍数是 100
* @param floatNum {number} 小数
* @return {object}
* {times:100, num: 314}
*/
function toInteger(floatNum) {
var ret = {times: 1, num: 0}
if (isInteger(floatNum)) {
ret.num = floatNum
return ret
}
var strfi = floatNum + ''
var dotPos = strfi.indexOf('.')
var len = strfi.substr(dotPos+1).length
var times = Math.pow(10, len)
var intNum = Number(floatNum.toString().replace('.',''))
ret.times = times
ret.num = intNum
return ret
}
/*
* 核心方法，实现加减乘除运算，确保不丢失精度
* 思路：把小数放大为整数（乘），进行算术运算，再缩小为小数（除）
*
* @param a {number} 运算数1
* @param b {number} 运算数2
* @param digits {number} 精度，保留的小数点数，比如 2, 即保留为两位小数
* @param op {string} 运算类型，有加减乘除（add/subtract/multiply/divide）
*
*/
function operation(a, b, digits, op) {
var o1 = toInteger(a)
var o2 = toInteger(b)
var n1 = o1.num
var n2 = o2.num
var t1 = o1.times
var t2 = o2.times
var max = t1 > t2 ? t1 : t2
var result = null
switch (op) {
case 'add':
if (t1 === t2) { // 两个小数位数相同
result = n1 + n2
} else if (t1 > t2) { // o1 小数位 大于 o2
result = n1 + n2 * (t1 / t2)
} else { // o1 小数位 小于 o2
result = n1 * (t2 / t1) + n2
}
return result / max
case 'subtract':
if (t1 === t2) {
result = n1 - n2
} else if (t1 > t2) {
result = n1 - n2 * (t1 / t2)
} else {
result = n1 * (t2 / t1) - n2
}
return result / max
case 'multiply':
result = (n1 * n2) / (t1 * t2)
return result
case 'divide':
result = (n1 / n2) * (t2 / t1)
return result
}
}
// 加减乘除的四个接口
function add(a, b, digits) {
return operation(a, b, digits, 'add')
}
function subtract(a, b, digits) {
return operation(a, b, digits, 'subtract')
}
function multiply(a, b, digits) {
return operation(a, b, digits, 'multiply')
}
function divide(a, b, digits) {
return operation(a, b, digits, 'divide')
}
// exports
return {
add: add,
subtract: subtract,
multiply: multiply,
divide: divide
}
}();
二、大数溢出问题
先直观感受一下，什么是大数溢出：
console.log(123456789012345678901) // => 123456789012345680000
2.1 为什么会出现大数溢出
JS Number 类型存储使用的 64 位双精度浮点型，1 位符号位，11 位表示指数 E，剩下 52 位是有效数字。
所以 JS 的数字只有在 [-(Math.pow(2,53)-1), Math.pow(2,53)-1] 的范围内才符合规范。
JS 也提供了最大/最小安全数 Number.MAX_SAFE_INTEGER 和 Number.MIN_SAFE_INTEGER, 以及方法 Number.isSafeInteger()以供对比。
（真正转变为 Infinity 的数其实也是有的，就是大于等于 Math.pow(2,1024)
2.2 解决
2.2.1 改为 String 类型
改用 string 类型，前后端传值时进行约定
巨大的金额，比如津巴布韦币 10 万亿津元兑换 2 美分
2.2.2 ES6 BigInt
const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)
// ↪ 9007199254740991n
const maxPlusOne = previousMaxSafe + 1n
// ↪ 9007199254740992n
const theFuture = previousMaxSafe + 2n
// ↪ 9007199254740993n, this works now!
const multi = previousMaxSafe * 2n
// ↪ 18014398509481982n
const subtr = multi - 10n
// ↪ 18014398509481972n
const mod = multi % 10n
// ↪ 2n
const bigN = 2n ** 54n
// ↪ 18014398509481984n
bigN * -1n
// ↪ -18014398509481984n
2.2.3 手写算法
大数相加是一个常见的算法
function sum(str1, str2) {
const arr1 = str1.split(''),arr2 = str2.split('');
const len1 = arr1.length,len2 = arr2.length;
const maxLen = Math.max(len1, len2);
let res = [];
let flag = false;
for(let i = 0; i < maxLen; i++) {
let temp;
let num1 = arr1.pop() , num2 = arr2.pop();
num1 = num1 ? num1 : 0;
num2 = num2 ? num2 : 0;
if(flag) {
temp = parseInt(num1) + parseInt(num2) + 1;
} else {
temp = parseInt(num1) + parseInt(num2);
}
if(parseInt(temp/10) > 0) {
// 有进位
res.push(temp%10);
flag = true;
} else {
res.push(temp);
flag = false;
}
if( i == maxLen -1 && flag) {
res.push(1);
}
}
return res.reverse().join('');
}
// 验证
sum('987654321111234','99900334444') // '987754221445678'
第三方库 bignumber
生产环境，使用第三方库是个比较好的方案。
