我的回答可能会迟到，但我的解决方案是：

函数浮点（方程式，精度=9）{return Math.floor（公式*（10**精度））/（10**精确度）；}console.log（浮点（0.1*0.2））；//=>0.02console.log（浮点（0.2+0.4））；//=>0.6console.log（浮点（1/3））；//=>0.333333333console.log（浮点（1/3，2））；//=>0.33

要处理任意浮点数，请执行以下操作：

function shorten(num) {
    num += 0.000000001;// to deal with "12.03999999997" form
    num += '';
    return num.replace(/(\.\d*?)0{5,}\d+$/, '$1') * 1;
}

console.log(1.2+1.9===1.3+1.8);// false
console.log(shorten(1.2+1.9)===shorten(1.3+1.8));// true

令人惊讶的是，这个函数还没有发布，尽管其他函数也有类似的变体。它来自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（）页面，所以也许有人可以提供更好的解决方案。

var times = function (a, b) {
    return Math.round((a * b) * 100)/100;
};

---或---

var fpFix = function (n) {
    return Math.round(n * 100)/100;
};

fpFix(0.1*0.2); // -> 0.02

---此外---

var fpArithmetic = function (op, x, y) {
    var n = {
            '*': x * y,
            '-': x - y,
            '+': x + y,
            '/': x / y
        }[op];        

    return Math.round(n * 100)/100;
};

---如中所示---

fpArithmetic('*', 0.1, 0.2);
// 0.02

fpArithmetic('+', 0.1, 0.2);
// 0.3

fpArithmetic('-', 0.1, 0.2);
// -0.1

fpArithmetic('/', 0.2, 0.1);
// 2

从我的角度来看，这里的想法是将fp数舍入，以便获得一个漂亮/简短的默认字符串表示。

53位有效位精度提供15到17位有效小数位数精度（2−53≈1.11×10−16）。如果具有最多15个有效数字的十进制字符串被转换为IEEE 754双精度表示，然后转换回具有相同位数的十进制字符串，最终结果应与原始字符串匹配。如果IEEE 754双精度数字被转换为具有至少17个有效数字的十进制字符串，然后转换回双精度表示，最终结果必须与原始数字匹配。...由于分数（F）有效位的52位出现在内存格式中，因此总精度为53位（约16位小数，53 log10（2）≈15.955）。。。维基百科

(0.1).toPrecision(100) ->
0.1000000000000000055511151231257827021181583404541015625000000000000000000000000000000000000000000000

(0.1+0.2).toPrecision(100) ->
0.3000000000000000444089209850062616169452667236328125000000000000000000000000000000000000000000000000

然后，据我所知，我们可以将值四舍五入到15位，以保持良好的字符串表示。

10**Math.floor(53 * Math.log10(2)) // 1e15

eg.

Math.round((0.2+0.1) * 1e15 ) / 1e15
0.3

(Math.round((0.2+0.1) * 1e15 ) / 1e15).toPrecision(100)
0.2999999999999999888977697537484345957636833190917968750000000000000000000000000000000000000000000000

功能如下：

function roundNumberToHaveANiceDefaultStringRepresentation(num) {

    const integerDigits = Math.floor(Math.log10(Math.abs(num))+1);
    const mult = 10**(15-integerDigits); // also consider integer digits
    return Math.round(num * mult) / mult;
}

您可以使用正则表达式检查数字是否以0的长字符串结尾，后跟一个小余数：

// using max number of 0s = 8, maximum remainder = 4 digits
x = 0.1048000000000051
parseFloat(x.toString().replace(/(\.[\d]+[1-9])0{8,}[1-9]{0,4}/, '$1'), 10)
// = 0.1048