Js計算精度缺失問題
阿新 • • 發佈：2020-12-15
技術標籤：javascriptvue.jstypescript
Js計算精度缺失問題
計算 239.45*100 = 2435.94.999999
常用解決方案
function accMul(arg1, arg2) {
var m = 0,
s1 = arg1.toString(),
s2 = arg2.toString()
try {
m += s1.split('.')[1].length
} catch (e) {}
try {
m += s2.split('.')[1]. 原因
計算機的二進位制實現和位數限制有些數無法有限表示。就像一些無理數不能有限表示，如 圓周率 3.1415926…，1.3333… 等。JS 遵循 IEEE 754 規範，採用雙精度儲存（double precision），佔用 64 bit。
如圖
即
- 1位用來表示符號位
- 11位用來表示指數
- 52位表示尾數
例如
1.浮點數
0.1 >> 0.0001 1001 1001 1001…（1001無限迴圈）
0.2 >> 0.0011 0011 0011 0011…（0011無限迴圈）
此時只能模仿十進位制進行四捨五入了，但是二進位制只有 0 和 1 兩個，於是變為 0 舍 1 入。這即是計算機中部分浮點數運算時出現誤差，丟失精度的根本原因。
大整數的精度丟失和浮點數本質上是一樣的，尾數位最大是 52 位，因此 JS 中能精準表示的最大整數是 Math.pow(2, 53)，十進位制即 9007199254740992。
大於 9007199254740992 的可能會丟失精度
即
9007199254740992 + 1 ``// 丟失 9007199254740992 + 2 ``// 未丟失 9007199254740992 + 3 ``// 丟失 9007199254740992 + 4 ``// 未丟失
解決方法
對於整數，前端出現問題的機率可能比較低，畢竟很少有業務需要需要用到超大整數，只要運算結果不超過 Math.pow(2, 53) 就不會丟失精度。
對於小數，前端出現問題的機率還是很多的，尤其在一些電商網站涉及到金額等資料。解決方式：把小數放到位整數（乘倍數），再縮小回原來倍數（除倍數）
先乘再縮小函式解決
/**
* floatObj 包含加減乘除四個方法，能確保浮點數運算不丟失精度
*
* 我們知道計算機程式語言裡浮點數計算會存在精度丟失問題（或稱舍入誤差），其根本原因是二進位制和實現位數限制有些數無法有限表示
* 以下是十進位制小數對應的二進位制表示
* 0.1 >> 0.0001 1001 1001 1001…（1001無限迴圈）
* 0.2 >> 0.0011 0011 0011 0011…（0011無限迴圈）
* 計算機裡每種資料型別的儲存是一個有限寬度，比如 JavaScript 使用 64 位儲存數字型別，因此超出的會捨去。捨去的部分就是精度丟失的部分。
*
* ** method **
* add / subtract / multiply /divide
*
* ** explame **
* 0.1 + 0.2 == 0.30000000000000004 （多了 0.00000000000004）
* 0.2 + 0.4 == 0.6000000000000001 （多了 0.0000000000001）
* 19.9 * 100 == 1989.9999999999998 （少了 0.0000000000002）
*
* 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}
var isNegative = floatNum < 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 = parseInt(Math.abs(floatNum) * times + 0.5, 10)
ret.times = times
if (isNegative) {
intNum = -intNum
}
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
}
}();
toFixed 修復
//四捨五入
Number((0.1+0.2).toFixed(2))
function toFixed(num, s) {
var times = Math.pow(10, s)
var des = num * times + 0.5
des = parseInt(des, 10) / times
return des + ''
}
toFixed 相容修復方案
通過判斷最後一位是否大於等於5來決定需不需要進位，如果需要進位先把小數乘以倍數變為整數，加1之後，再除以倍數變為小數，這樣就不用一位一位的進行判斷。
// toFixed相容方法
Number.prototype.toFixed = function(len){
if(len>20 || len<0){
throw new RangeError('toFixed() digits argument must be between 0 and 20');
}
// .123轉為0.123
var number = Number(this);
if (isNaN(number) || number >= Math.pow(10, 21)) {
return number.toString();
}
if (typeof (len) == 'undefined' || len == 0) {
return (Math.round(number)).toString();
}
var result = number.toString(),
numberArr = result.split('.');
if(numberArr.length<2){
//整數的情況
return padNum(result);
}
var intNum = numberArr[0], //整數部分
deciNum = numberArr[1],//小數部分
lastNum = deciNum.substr(len, 1);//最後一個數字
if(deciNum.length == len){
//需要擷取的長度等於當前長度
return result;
}
if(deciNum.length < len){
//需要擷取的長度大於當前長度 1.3.toFixed(2)
return padNum(result)
}
//需要擷取的長度小於當前長度，需要判斷最後一位數字
result = intNum + '.' + deciNum.substr(0, len);
if(parseInt(lastNum, 10)>=5){
//最後一位數字大於5，要進位
var times = Math.pow(10, len); //需要放大的倍數
var changedInt = Number(result.replace('.',''));//擷取後轉為整數
changedInt++;//整數進位
changedInt /= times;//整數轉為小數，注：有可能還是整數
result = padNum(changedInt+'');
}
return result;
//對數字末尾加0
function padNum(num){
var dotPos = num.indexOf('.');
if(dotPos === -1){
//整數的情況
num += '.';
for(var i = 0;i<len;i++){
num += '0';
}
return num;
} else {
//小數的情況
var need = len - (num.length - dotPos - 1);
for(var j = 0;j<need;j++){
num += '0';
}
return num;
}
}
}