JS的四则运算

JS在计算小数的时候有时会出现精度问题，相信很多人有遇到过，今天特地总结一下。
## 问题 ##
0.1 + 0.2 = 0.30000000000000004
0.1 * 0.2 = 0.020000000000000004
......

为什么会出现这样的情况呢？
浮点数值的最高进度是17位小数，但在进行运算的时候其精确度却远远不如整数；整数在进行运算的时候都会转成10进制； 而Java和JavaScript中计算小数运算时，都会先将十进制的小数换算到对应的二进制，一部分小数并不能完整的换算为二进制，这里就出现了第一次的误差。待小数都换算为二进制后，再进行二进制间的运算，得到二进制结果。然后再将二进制结果换算为十进制，这里通常会出现第二次的误差。

解决方法：

/**	
	除法
	调用方式：
	var number = new Number();
	console.log(number.div(0.2, 0.10));
**/
			function acctDiv(arg1, arg2) {
	                var r1 = Number(arg1.toString().replace(".", ""));
	                var r2 = Number(arg2.toString().replace(".", ""));
	                var l1 = 0;
	                var l2 = 0;
                    var l3 = 0;
	                try {
	                    l1 =  Number(arg1.toString().split(".")[1].length);
	                } catch (e) {
	                    l1 = 0;
	                }
	 
	                try {
	                    l2 = Number(arg2.toString().split(".")[1].length);
	                } catch (e) {
	                    l2 = 0;
	                }
	                
	                var pow = Math.pow(10, Math.max(l1, l2));
	 
	                //先把结果放大一定倍数，再去移动相应位数
	                var result = r1 / r2;
                    console.log(result)
                    try {
                        l3 = Number(result.toString().split(".")[1].length);
                    } catch (e) {
                        l3 = 0;
                    }
	               
                    var pow3 = Math.pow(10, l3);
                    
                    try {
                        result = Number(result.toString().replace(".", ""));
                    } catch (e) {

                    }
                    
	                result = result * pow * Math.pow(10, l2 - l1) / (pow * pow3);
	                console.log("result=" + result);
	                return result;
	            }
			
			/**
				乘法
				调用方式：
				var number = new Number();
				console.log(number.mul(0.0002, 0.02));
			**/
			function acctMul(arg1, arg2) {
				var r1 = Number(arg1.toString().replace(".", ""));
				var r2 = Number(arg2.toString().replace(".", ""));
				var m = 0;
				
				try {
					m += arg1.toString().split(".")[1].length;
				} catch (e) {
					m += 0;
				}
				
				try {
					m += arg2.toString().split(".")[1].length;
				} catch (e) {
					m += 0;
				}
				var result = (r1 * r2) / Math.pow(10, m);
				return result;
			}
			
			/**
				加法或减法
				调用方式：
				var number = new Number();
				console.log(number.addOrSub(0.1, 0.2));
			**/
			function acctAddOrSub(arg1, arg2) {
				var r1 = 0;
				var r2 = 0;
				var m = 0;
				try {
					r1 = arg1.toString().split(".")[1].length;
				} catch (e) {
					r1 = 0;
				}
				
				try {
					r2 = arg2.toString().split(".")[1].length;
				} catch (e) {
					r2 = 0;
				}
				
				m = Math.pow(10, Math.max(r1, r2));
				var result = (arg1 * m + arg2 * m) / m;
				return result;
			}
			
			/**
				除法运算
			**/
			Number.prototype.div = function(arg1, arg2) {
				return acctDiv(arg1, arg2);
			}
			
			/**
				乘法运算
			**/
			Number.prototype.mul = function(arg1, arg2) {
				return acctMul(arg1, arg2);
			}
			
			/**
				加减法运算
			**/
			Number.prototype.addOrSub = function(arg1, arg2) {
				return acctAddOrSub(arg1, arg2);
			}

上面的解放方法的原来基本都是通过把要计算的数放到到一定倍数进行运算后再转化回来，这个一定的倍数太小了也不行，我也是通过测试才得到上面比较合理的转换，当然也还有其他的解决方式，就是通过## toFixed() ## 函数去截取一定的精度，当然伴随着就是精度的缺失。
参考文档：http://www.cnblogs.com/zdz8207/p/js-number-tofixed.html