如：9999999999999999 === 10000000000000001
如：1.335.toFixed(2) // 1.33；1.336.toFixed(2) // 1.34
二进制模仿十进制进行四舍五入，而二进制只有0和1，于是就0舍1入，于是就导致了小数计算不精确。大数的精度丢失本质上是和小数一样，js中表示最大的数是Math.pow(2, 53),十进制即 9007199254740992；大于该数的值可能会丢失精度。
小数的话，一般转成整数进行计算，然后对结果做除法；同样也可以直接对结果进行4舍5入；
对于大数出现的问题概率较低，毕竟还要运算结果不超过最大数就不会丢失精度；
javaScript数字精度丢失问题总结
js中精度问题以及解决方案
JavaScript 中精度问题以及解决方案
Math.add = function(v1, v2){
///<summary>精确计算加法。语法：Math.add(v1, v2)</summary>
///<param name="v1" type="number">操作数。</param>
///<param name="v2" type="number">操作数。</param>
///<returns type="number">计算结果。</returns>
var r1, r2, m
try
{
r1 = v1.toString().split(".")[1].length
}
catch (e)
{
r1 = 0
}
try
{
r2 = v2.toString().split(".")[1].length
}
catch (e)
{
r2 = 0
}
m = Math.pow(10, Math.max(r1, r2))
return (v1 * m + v2 * m) / m
}
Number.prototype.add = function(v)
{
///<summary>精确计算加法。语法：number1.add(v)</summary>
///<param name="v" type="number">操作数。</param>
///<returns type="number">计算结果。</returns>
return Math.add(v, this)
}
Math.sub = function(v1, v2)
{
///<summary>精确计算减法。语法：Math.sub(v1, v2)</summary>
///<param name="v1" type="number">操作数。</param>
///<param name="v2" type="number">操作数。</param>
///<returns type="number">计算结果。</returns>
return Math.add(v1, -v2)
}
Number.prototype.sub = function(v)
{
///<summary>精确计算减法。语法：number1.sub(v)</summary>
///<param name="v" type="number">操作数。</param>
///<returns type="number">计算结果。</returns>
return Math.sub(this, v)
}
Math.mul = function(v1, v2)
{
///<summary>精确计算乘法。语法：Math.mul(v1, v2)</summary>
///<param name="v1" type="number">操作数。</param>
///<param name="v2" type="number">操作数。</param>
///<returns type="number">计算结果。</returns>
var m = 0
var s1 = v1.toString()
var s2 = v2.toString()
try
{
m += s1.split(".")[1].length
}
catch (e)
{
}
try
{
m += s2.split(".")[1].length
}
catch (e)
{
}
return Number(s1.replace(".", "")) * Number(s2.replace(".", "")) / Math.pow(10, m)
}
Number.prototype.mul = function(v)
{
///<summary>精确计算乘法。语法：number1.mul(v)</summary>
///<param name="v" type="number">操作数。</param>
///<returns type="number">计算结果。</returns>
return Math.mul(v, this)
}
Math.div = function(v1, v2)
{
///<summary>精确计算除法。语法：Math.div(v1, v2)</summary>
///<param name="v1" type="number">操作数。</param>
///<param name="v2" type="number">操作数。</param>
///<returns type="number">计算结果。</returns>
var t1 = 0
var t2 = 0
var r1, r2
try
{
t1 = v1.toString().split(".")[1].length
}
catch (e)
{
}
try
{
t2 = v2.toString().split(".")[1].length
}
catch (e)
{
}
with (Math)
{
r1 = Number(v1.toString().replace(".", ""))
r2 = Number(v2.toString().replace(".", ""))
return (r1 / r2) * pow(10, t2 - t1)
}
}
Number.prototype.div = function(v)
{
///<summary>精确计算除法。语法：number1.div(v)</summary>
///<param name="v" type="number">操作数。</param>
///<returns type="number">计算结果。</returns>
return Math.div(this, v)
}
浮点数值的最高精度是17位小数，但在进行运算的时候其精确度却远远不如整数；整数在进行运算的时候都会转成10进制； 而java和JavaScript中计算小数运算时，都会先将十进制的小数换算到对应的二进制，一部分小数并不能完整的换算为二进制，这里就出现了第一次的误差。待小数都换算为二进制后，再进行二进制间的运算，得到二进制结果。然后再将二进制结果换算为十进制，这里通常会出现第二次的误差。
所以(0.1+0.2)!=03
解决这种问题，可以将小数变成整数进行运算，然后再将结果变为小数。
//乘法
function multiNum (a,b){
var c = 0,
d = a.toString(),
e = b.toString()
try {
c += d.split(".")[1].length
} catch (f) { }
try {
c += e.split(".")[1].length
} catch (f) { }
return Number(d.replace(".","")) * Number(e.replace(".","")) / Math.pow(10,c)
}
//除法
function divide (a,b){
var c,d,e = 0,
f = 0
try {
e = a.toString().split(".")[1].length
} catch (g) { }
try {
f = b.toString().split(".")[1].length
} catch (g) { }
return c = Number(a.toString().replace(".","")),d = Number(b.toString().replace(".","")),this.mul(c / d,Math.pow(10,f - e))
}
//加法
function addNum (a,b){
var c,d,e
try {
c = a.toString().split(".")[1].length
} catch (f) {
c = 0
}
try {
d = b.toString().split(".")[1].length
} catch (f) {
d = 0
}
return e = Math.pow(10,Math.max(c,d)),(multiNum(a,e) + multiNum(b,e)) / e
}
//减法
function subNum (a,b) {
var c,d,e
try {
c = a.toString().split(".")[1].length
} catch (f) {
c = 0
}
try {
d = b.toString().split(".")[1].length
} catch (f) {
d = 0
}
return e = Math.pow(10,Math.max(c,d)),(multiNum(a,e) - multiNum(b,e)) / e
}
