關於javascript中對浮點加，減，乘，除的精度分析

龍恩0707發表於2014-01-08
JavaScript

   大學專業是計算機童鞋或多或小的知道 計算機是由二進位制儲存和處理數字的，不能精確到處理浮點數，且javascript也沒有這樣的方法 所以在瀏覽器計算的時候也會有誤差，比如說 我想用 3.3 / 1.1  那麼按道理來說 答案是 3 ，對不對 但是我們可以列印出來看下 結果令我們很驚訝 是 2.9999999999999996 .現在我們想 為了避免產生精度差異，需要計算的數字升級（乘以10的n次冪）成計算機能夠精確識別的整數，等計算完畢再降級（除以10的n次冪）. 這樣處理下 就可以實現正常的結果。

基本原理：

   需要計算的數字升級（乘以10的n次冪）成計算機能夠精確識別的整數，等計算完畢再降級（除以10的n次冪）. 這樣處理下 就可以實現正常的結果。

 Javascript 如何解決對 "加法" 精度問題

       其實不管對於 加法，減法 乘法及除法也好 其基本原理都是一樣 先乘以10的n次冪 成計算機能夠識別的整數 然後計算 計算完成後 再除以10的n次冪 這樣就可以得到想要的結果。

   現在我們先列舉個列子 比如：var a = 1.3, b = 2.3；那麼 我通過在火狐瀏覽器列印一下console.log(a+b)=? 結果在火狐瀏覽器下看到等於：3.5999999999999996 .這也就是說計算機對浮點計算存在精度問題。而現在我們想寫個js函式方法，來避免這種情況的產生。

   函式的基本原理：先傳入2個引數 分別為arg1,arg2;先判斷下 如果2個引數都是浮點數的話 那麼取得該2個引數的小數點後面的長度，分別儲存到變數為firstArg，lastArg; 否則的話 如果那個引數不是浮點的話 那麼讓此fisrtArg或者lastArg賦值為0. 然後取得差值 differ = Math.abs(firstArg - lastArg).(目的是為了下面判斷他們的小數點位數是否相同。) 接著獲取最大的n次冪 如： m = Math.pow(10,Math.max(firstArg,lastArg));

   1. 接著上面的話說，如果小數點後面的位數長度相同的話 比如說 1.3 和 2.3 小數點後的數字都是3，那麼他們的長度都是相同的的(為1).那麼先變為整數 去掉小數點後計算 如：arg1 = Number(arg1.toString().replace(".", ""));arg2 = Number(arg2.toString().replace(".", "")); 然後接著再除以他們的n次冪 如：return (arg1 + arg2) / m; 這樣可以返回結果。

   2. 如果小數點後面的位數長度不一致的話 先通過他們的差值 differ獲取n次冪 如：var dm = Math.pow(10,differ); 再判斷 如果 firstArg > lastArg 那麼 arg1 = Number(arg1.toString().replace(".", "")); arg2 = Number(arg2.toString().replace(".", "")) * dm;否則的話 arg1 = Number(arg1.toString().replace(".", "")) * dm; arg2 = Number(arg2.toString().replace(".", "")); 再比如：var a = 1.31,b = 2.3; 那麼 firstArg的長度為2 lastArg長度為1；因為 2 > 1 那麼 arg1 = 131; arg2 = 23 * dm(如上：dm = Math.pow(10,differ));最後計算如：return (arg1 + arg2) / m --> (arg1 + arg2) / m  ---> (131 + 23*10) / Math.pow(10,Math.max(firstArg,lastArg)); --> 

 (131 + 230) / Math.pow(10,2) --> 361 / 100 = 3.61; 和1.31 + 2.3 結果一致。同理firstArg < lastArg也是一樣的原理。這裡不多說了。

 為了更詳細的說明問題 我們可以先來看看流程圖：如下：

  

下面是JS函式程式碼如下：

/**
 * js加法 解決精度問題
 */

 function addFun(arg1,arg2) {
    var firstArg,
        lastArg,
        differ,
        m;
    try{
        firstArg = arg1.toString().split('.')[1].length;
    }
    catch (e){
        firstArg = 0;
    }

    try{
        lastArg = arg2.toString().split('.')[1].length;
    }
    catch (e){
        lastArg = 0;
    }
    differ = Math.abs(firstArg - lastArg);
    m = Math.pow(10,Math.max(firstArg,lastArg));
    
    if(differ > 0) {
        var dm = Math.pow(10,differ);
        if(firstArg > lastArg) {
            arg1 = Number(arg1.toString().replace(".", ""));
            arg2 = Number(arg2.toString().replace(".", "")) * dm;

        }else {
            arg1 = Number(arg1.toString().replace(".", "")) * dm;
            arg2 = Number(arg2.toString().replace(".", ""));
        }
     }else {
        arg1 = Number(arg1.toString().replace(".", ""));
        arg2 = Number(arg2.toString().replace(".", ""));
    }
    return (arg1 + arg2) / m;
 }
View Code

 Javascript 如何解決對 "減法" 精度問題

  同樣現在我們先列舉個列子 比如：var a = 1.3, b = 2.3；那麼 我通過在火狐瀏覽器列印一下console.log(b-a)=? 結果在火狐瀏覽器下看到等於：0.9999999999999998.同樣我們想寫個js函式方法，來避免這種情況的產生

程式碼實現原理是：先傳入2個引數 分別為arg1,arg2;先判斷下 如果2個引數都是浮點數的話 那麼取得該2個引數的小數點後面的長度，分別儲存到變數為firstArg，lastArg; 否則的話 如果那個引數不是浮點的話 那麼讓此fisrtArg或者lastArg賦值為0. 然後獲取他們的最大n次冪如：

differ = Math.pow(10, Math.max(firstArg, lastArg)); 接著如下判斷 如果firstArg的長度大於lastArg的長度 那麼返回firstArg,否則返回lastArg; 如：m = (firstArg > lastArg) ? firstArg : lastArg;最後返回 return ((arg1 * differ - arg2 * differ) / differ).toFixed(m); 接著再列舉列子 比如還是上面 傳入a=2.3, b = 1.3 那麼他們的長度相等(都為1) 即：differ = Math.pow(10,1);

m = lastArg = 1; 最後返回 ((arg1 * differ - arg2 * differ) / differ).toFixed(m) --> (2.3*10 - 1.3*10)/10.toFixed(1) = 1.0;

接著我們可以再列舉個反列：比如var b = 2.31, a = 1.3; 那麼他們的長度不相等 即(b的小數點後面的長度為2 > a的小數點後面的長度1) 那麼differ = Math.pow(10,Math(firstArg,lastArg)) -- > differ = Math.pow(10,2) --> differ = 100; m = firstArg = 2; 最後返回

((arg1*differ - arg2*differ)/differ).toFixed(m) --> (2.31*100 -1.3 * 100)/100.toFixed(2) = ((231-130)/100).toFixed(2) = 1.01; 和 b -a = 2.31 - 1.3 = 1.01結果相同 同樣推理正確。同樣我們來個簡單流程圖 如下：

 

下面是JS對減法解決精度的函式方法程式碼如下：

/*
  * JS減法 解決精度問題
  */

  function subtraction(arg1,arg2){
     var firstArg,
         lastArg,
         differ,
         m;
     try{
        firstArg = arg1.toString().split('.')[1].length;
     }catch (e){
        firstArg = 0;
     }

     try{
        lastArg = arg2.toString().split('.')[1].length;
     }
     catch (e){
        lastArg = 0;
     }
     differ = Math.pow(10, Math.max(firstArg, lastArg));
     m = (firstArg > lastArg) ? firstArg : lastArg;
     return ((arg1 * differ - arg2 * differ) /    differ).toFixed(m);
  }
View Code

 Javascript 如何解決對 "乘法" 精度問題

     同樣現在我們先列舉個列子 比如：var a = 1.3, b = 2.3；那麼 我通過在火狐瀏覽器列印一下console.log(a*b)=? 結果在火狐瀏覽器下看到等於：2.9899999999999998.但是實際的結果是：2.99 同樣我們想寫個js函式方法，來避免這種情況的產生.

  程式碼的實現原理是：先傳入2個引數 分別為arg1,arg2，先把這2個引數轉化為字串分別儲存到firstArg和lastArg裡面，如：

  firstArg = arg1.toString();lastArg = arg2.toString(); 接著定義個變數 m = 0;然後分別取到firstArg,lastArg的長度與m分別相加，如：m += firstArg.split('.')[1].length; m += lastArg.split('.')[1].length; 也就是說 m得到的就是 後面的小數點的位數。最後如下返回 return Number(firstArg.replace(".", "")) * Number(lastArg.replace(".", "")) / Math.pow(10, m);

  比如再列舉個列子 還是剛剛 a = 1.3, b = 2.3 來講，因為他們的firstArg和lastArg的長度都為1，也就是說 m = 2；那麼返回

  Number(firstArg.replace(".", "")) * Number(lastArg.replace(".", "")) / Math.pow(10, m) ---> 

  Number(13 * 23)/Math.pow(10,2) = 13*23 / 100 = 2.99 與我們的1.3×2.3 = 2.99 結果相同。同理我們也可以隨便列舉列子都可以的，在這就不一一列舉哦！有興趣的童鞋可以多列舉下。

實現的JS程式碼如下：

/**
   * JS乘法 解決精度問題
   */
  function multiplication(arg1,arg2) {
     var  m = 0,
         firstArg,
         lastArg;
     firstArg = arg1.toString();
     lastArg = arg2.toString();

     try{
        m += firstArg.split('.')[1].length;
     }
     catch (e){}

     try{
        m += lastArg.split('.')[1].length;
     }
     catch (e){}

     return Number(firstArg.replace(".", "")) * Number(lastArg.replace(".", "")) / Math.pow(10, m);
  }
View Code

 Javascript 如何解決對 "除法" 精度問題

    同樣現在我們先列舉個列子 比如：var a = 1.1, b = 3.3；那麼 我通過在火狐瀏覽器列印一下console.log(b/a)=? 結果在火狐瀏覽器下看到等於：2.9999999999999996.但是實際的結果是：3 同樣我們想寫個js函式方法，來避免這種情況的產生.

    程式碼實現的原理：先傳入2個引數 分別為arg1,arg2;先判斷下 如果2個引數都是浮點數的話 那麼取得該2個引數的小數點後面的長度，分別儲存到變數為firstArg，lastArg; 否則的話 如果那個引數不是浮點的話 那麼讓此fisrtArg或者lastArg賦值為0. 接著把小數點都去掉分別進行相應的運算：如 r1 = Number(arg1.toString().replace(".", ""));r2 = Number(arg2.toString().replace(".", ""));

那麼返回如下：return (r1 / r2) * Math.pow(10, lastArg - firstArg);就可以了。

 接著再列舉列子 比如var b = 3.3，a = 1.1 那麼firstArg和lastArg的長度都為1，那麼 r1 = Number(arg1.toString().replace(".", "")); --> r1 = 33; r2 = Number(arg2.toString().replace(".", "")); --> r2 = 11;那麼 返回是：

 return (r1 / r2) * Math.pow(10, lastArg - firstArg); --> （33/11）×Math.pow(10,0) = 3.和我們想要等到的結果3.3/1.1=3是一樣的，說明推理正確。同樣我們可以列舉個其他的列子都ok的 具體的可以自己去列舉下 這裡也不一一列舉了。

JS解決對"除法"精度問題的函式程式碼如下：

 

/*
   * JS除法 解決精度問題
   */
  function division(arg1,arg2) {
     var firstArg,
         lastArg,
         r1,
         r2;
     
     try{
        firstArg = arg1.toString().split(".")[1].length;
     }
     catch (e){
        firstArg = 0; 
     }

     try{
        lastArg = arg2.toString().split('.')[1].length;
     }
     catch (e){
        lastArg = 0;
     }
      r1 = Number(arg1.toString().replace(".", ""));
      r2 = Number(arg2.toString().replace(".", ""));

      return (r1 / r2) * Math.pow(10, lastArg - firstArg);
  }
View Code

 

 

 

相關文章