令人惊讶的是，这个函数还没有发布，尽管其他函数也有类似的变体。它来自MDN web docs for Math.rround（）。它简洁，允许不同的精度。

function precisionRound(number, precision) {
    var factor = Math.pow(10, precision);
    return Math.round(number * factor) / factor;
}

console.log(precisionRound(1234.5678, 1));
// expected output: 1234.6

console.log(precisionRound(1234.5678, -1));
// expected output: 1230

var inp=document.querySelectorAll（'input'）；var btn=document.querySelector（'按钮'）；btn.onclick=函数（）{inp[2].value=precisionRound（parseFloat（inp[0].value）*parseFlat（inp[1].value，5）；};//MDN功能函数精度Round（数字，精度）{var因子=数学功率（10，精度）；return数学舍入（number*factor）/factor；}按钮{显示：块；}<输入类型=“文本”值=“0.1”><输入类型=“文本”值=“0.2”><button>获取产品</button><input-type='text'>

更新日期：2019年8月20日

刚刚注意到这个错误。我认为这是由于Math.rround（）的浮点精度错误造成的。

precisionRound(1.005, 2) // produces 1, incorrect, should be 1.01

这些条件正常工作：

precisionRound(0.005, 2) // produces 0.01
precisionRound(1.0005, 3) // produces 1.001
precisionRound(1234.5, 0) // produces 1235
precisionRound(1234.5, -1) // produces 1230

Fix:

function precisionRoundMod(number, precision) {
  var factor = Math.pow(10, precision);
  var n = precision < 0 ? number : 0.01 / factor + number;
  return Math.round( n * factor) / factor;
}

这只是在舍入小数时向右加一个数字。MDN已经更新了Math.rround（）页面，所以也许有人可以提供更好的解决方案。

使用编号（1.234443）。至固定（2）；它将打印1.23

function test(){
    var x = 0.1 * 0.2;
    document.write(Number(x).toFixed(2));
}
test();

从浮点指南：

我可以做什么来避免这个问题？这取决于什么样的你正在做的计算。如果你真的需要你的结果精确相加，特别是当你使用货币：使用特殊小数数据类型。如果你只是不想看到所有多余的小数点：将结果四舍五入设置为固定格式小数位数显示它。如果没有可用的十进制数据类型，另一种方法是工作使用整数，例如，do money完全以美分计算。但是这是更多的工作，有一些缺点。

注意，第一点仅适用于您确实需要特定的精确小数行为的情况。大多数人不需要这样做，他们只是对自己的程序无法正确处理1/10这样的数字感到愤怒，而没有意识到如果出现1/3这样的错误，他们甚至不会眨眼。

如果第一点确实适用于您，请使用BigDecimal for JavaScript或DecimalJS，这实际上解决了问题，而不是提供不完美的解决方法。

我有一个变通办法。例如，仅与10E^x相乘不适用于1.1。

function sum(a,b){
    var tabA = (a + "").split(".");
    var tabB = (b + "").split(".");
    decA = tabA.length>1?tabA[1].length:0;
    decB = tabB.length>1?tabB[1].length:0;
    a = (tabA[0]+tabA[1])*1.0;
    b = (tabB[0]+tabB[1])*1.0;
    var diff = decA-decB;
    if(diff >0){
        //a has more decimals than b
        b=b*Math.pow(10,diff);
        return (a+b)/Math.pow(10,decA);
    }else if (diff<0){
        //a has more decimals than b
        a=a*Math.pow(10,-diff);
                return (a+b)/Math.pow(10,decB);
    }else{
        return (a+b)/Math.pow(10,decA);
    }       
}

可怕但有效：）

为了避免这种情况，您应该使用整数值而不是浮点。因此，当您希望使用值*100进行2个位置的精度工作时，对于3个位置使用1000。显示时，使用格式化程序放入分隔符。

许多系统省略了以这种方式处理小数。这就是为什么许多系统使用美分（作为整数）而不是美元/欧元（作为浮点）的原因。

对于数学倾向：http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html

推荐的方法是使用校正因子（乘以适当的10次方，以便在整数之间进行运算）。例如，在0.1*0.2的情况下，校正系数为10，您正在执行以下计算：

> var x = 0.1
> var y = 0.2
> var cf = 10
> x * y
0.020000000000000004
> (x * cf) * (y * cf) / (cf * cf)
0.02

一个（非常快速的）解决方案看起来像：

var _cf = (function() {
  function _shift(x) {
    var parts = x.toString().split('.');
    return (parts.length < 2) ? 1 : Math.pow(10, parts[1].length);
  }
  return function() { 
    return Array.prototype.reduce.call(arguments, function (prev, next) { return prev === undefined || next === undefined ? undefined : Math.max(prev, _shift (next)); }, -Infinity);
  };
})();

Math.a = function () {
  var f = _cf.apply(null, arguments); if(f === undefined) return undefined;
  function cb(x, y, i, o) { return x + f * y; }
  return Array.prototype.reduce.call(arguments, cb, 0) / f;
};

Math.s = function (l,r) { var f = _cf(l,r); return (l * f - r * f) / f; };

Math.m = function () {
  var f = _cf.apply(null, arguments);
  function cb(x, y, i, o) { return (x*f) * (y*f) / (f * f); }
  return Array.prototype.reduce.call(arguments, cb, 1);
};

Math.d = function (l,r) { var f = _cf(l,r); return (l * f) / (r * f); };

在这种情况下：

> Math.m(0.1, 0.2)
0.02

我绝对建议使用SinfulJS这样的测试库