第JS中浮點數精度問題的分析與解決方法目錄前言問題的發現浮點數運算后的精度問題toFixed奇葩問題為什么會產生浮點數的存儲浮點數的運算解決方法解決toFixed解決浮點數運算精度附：JS浮點數精度問題的一些實用建議總結

前言

最近在做項目的時候，涉及到商品價格的計算，經常會出現計算出現精度問題。剛開始草草了事，直接用toFixed就解決了問題，并沒有好好的思考一下這個問題。后來慢慢的，問題越來越多，連toFixed也出現了（允悲），后來經過搜索網上的各種博客和論壇，整理總結了一下。

問題的發現

總結了一下，一共有以下兩種問題

浮點數運算后的精度問題

在計算商品價格加減乘除時，偶爾##會出現精度問題，一些常見的例子如下：

//加法=====================

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

toFixed奇葩問題

在遇到浮點數運算后出現的精度問題時，剛開始我是使用toFixed(2)來解決的，因為在W3school和菜鳥教程（他們均表示這鍋不背）上明確寫著定義：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錯誤

使用IETester在IE下面測試的結果卻是正確的。

為什么會產生

讓我們來看一下為什么0.1+0.2會等于0.30000000000000004，而不是0.3。首先，想要知道為什么會產生這樣的問題，讓我們回到大學里學的復（ku）雜（zao）的計算機組成原理。雖然已經全部還給大學老師了，但是沒關系，我們還有百度嘛。

浮點數的存儲

和其它語言如Java和Python不同，JavaScript中所有數字包括整數和小數都只有一種類型Number。它的實現遵循IEEE754標準，使用64位固定長度來表示，也就是標準的double雙精度浮點數（相關的還有float32位單精度）。

這樣的存儲結構優點是可以歸一化處理整數和小數，節省存儲空間。

64位比特又可分為三個部分：

符號位S：第1位是正負數符號位（sign），0代表正數，1代表負數

指數位E：中間的11位存儲指數（exponent），用來表示次方數

尾數位M：最后的52位是尾數（mantissa），超出的部分自動進一舍零

浮點數的運算

那么JavaScript在計算0.1+0.2時到底發生了什么呢？

首先，十進制的0.1和0.2會被轉換成二進制的，但是由于浮點數用二進制表示時是無窮的：

0.1-0.0001100110011001...(1100循環)

0.2-0.0011001100110011...(0011循環)

IEEE754標準的64位雙精度浮點數的小數部分最多支持53位二進制位，所以兩者相加之后得到二進制為：

0.0100110011001100110011001100110011001100110011001100

因浮點數小數位的限制而截斷的二進制數字，再轉換為十進制，就成了0.30000000000000004。所以在進行算術計算時會產生誤差。

解決方法

針對以上兩個問題，網上搜了一波解決方法，基本都大同小異的，分別來看一下。

解決toFixed

針對toFixed的兼容性問題，我們可以把toFix重寫一下來解決，代碼如下：

//toFixed兼容方法

Ntotype.toFixed=function(len){

if(len20||len0){

thrownewRangeError('toFixed()digitsargumentmustbebetween0and20');

//.123轉為0.123

varnumber=Number(this);

if(isNaN(number)||number=Math.pow(10,21)){

returnnumber.toString();

if(typeof(len)=='undefined'||len==0){

return(Math.round(number)).toString();

varresult=number.toString(),

numberArr=result.split('.');

if(numberArr.length2){

//整數的情況

returnpadNum(result);

varintNum=numberArr[0],//整數部分

deciNum=numberArr[1],//小數部分

lastNum=deciNum.substr(len,1);//最后一個數字

if(deciNum.length==len){

//需要截取的長度等于當前長度

returnresult;

if(deciNum.lengthlen){

//需要截取的長度大于當前長度1.3.toFixed(2)

returnpadNum(result)

//需要截取的長度小于當前長度，需要判斷最后一位數字

result=intNum+'.'+deciNum.substr(0,len);

if(parseInt(lastNum,10)=5){

//最后一位數字大于5，要進位

vartimes=Math.pow(10,len);//需要放大的倍數

varchangedInt=Number(result.replace('.',''));//截取后轉為整數

changedInt++;//整數進位

changedInt/=times;//整數轉為小數，注：有可能還是整數

result=padNum(changedInt+'');

returnresult;

//對數字末尾加0

functionpadNum(num){

vardotPos=num.indexOf('.');

if(dotPos===-1){

//整數的情況

num+='.';

for(vari=0;ii++){

num+='0';

returnnum;

}else{

//小數的情況

varneed=len-(num.length-dotPos-1);

for(varj=0;jneed;j++){

num+='0';

returnnum;

}

我們通過判斷最后一位是否大于等于5來決定需不需要進位，如果需要進位先把小數乘以倍數變為整數，加1之后，再除以倍數變為小數，這樣就不用一位一位的進行判斷。

解決浮點數運算精度

既然我們發現了浮點數的這個問題，又不能直接讓兩個浮點數運算，那怎么處理呢？

我們可以把需要計算的數字升級（乘以10的n次冪）成計算機能夠精確識別的整數，等計算完成后再進行降級（除以10的n次冪），這是大部分變成語言處理精度問題常用的方法。例如：

0.1+0.2==0.3//false

(0.1*10+0.2*10)/10==0.3//true

但是這樣就能完美解決么？細心的讀者可能在上面的例子里已經發現了問題：

35.41*100=3540.9999999999995

看來進行數字升級也不是完全的可靠啊（允悲）。

但是魔高一尺道高一丈，這樣就能難住我們么，我們可以將浮點數toString后indexOf(.)，記錄一下小數位的長度，然后將小數點抹掉，完整的代碼如下：

/***method**

*add/subtract/multiply/divide

*floatObj.add(0.1,0.2)0.3

*floatObj.multiply(19.9,100)1990

varfloatObj=function(){

*判斷obj是否為一個整數

functionisInteger(obj){

returnMath.floor(obj)===obj

*將一個浮點數轉成整數，返回整數和倍數。如3.14314，倍數是100

*@paramfloatNum{number}小數

*@return{object}

*{times:100,num:314}

functiontoInteger(floatNum){

varret={times:1,num:0}

if(isInteger(floatNum)){

ret.num=floatNum

returnret

varstrfi=floatNum+''

vardotPos=strfi.indexOf('.')

varlen=strfi.substr(dotPos+1).length

vartimes=Math.pow(10,len)

varintNum=Number(floatNum.toString().replace('.',''))

ret.times=times

ret.num=intNum

returnret

*核心方法，實現加減乘除運算，確保不丟失精度

*思路：把小數放大為整數（乘），進行算術運算，再縮小為小數（除）

*@parama{number}運算數1

*@paramb{number}運算數2

*@paramdigits{number}精度，保留的小數點數，比如2,即保留為兩位小數

*@paramop{string}運算類型，有加減乘除（add/subtract/multiply/divide）

functionoperation(a,b,digits,op){

varo1=toInteger(a)

varo2=toInteger(b)

varn1=o1.num

varn2=o2.num

vart1=o1.times

vart2=o2.times

varmax=t1t2t1:t2

varresult=null

switch(op){

case'add':

if(t1===t2){//兩個小數位數相同

result=n1+n2

}elseif(t1t2){//o1小數位大于o2

result=n1+n2*(t1/t2)

}else{//o1小數位小于o2

result=n1*(t2/t1)+n2

returnresult/max

case'subtract':

if(t1===t2){

result=n1-n2

}elseif(t1t2){

result=n1-n2*(t1/t2)

}else{

result=n1*(t2/t1)-n2

returnresult/max

case'multiply':

result=(n1*n2)/(t1*t2)

returnresult

case'divide':

result=(n1/n2)*(t2/t1)

returnresult

//加減乘除的四個接口

functionadd(a,b,digits){

returnoperation(a,b,digits,'add')

functionsubtract(a,b,