0.6*3太棒了！）对我来说，这很好：

function dec( num )
{
    var p = 100;
    return Math.round( num * p ) / p;
}

非常简单））

你是对的，原因是浮点数的精度有限。将有理数存储为两个整数的除法，在大多数情况下，您可以存储数字而不损失任何精度。在打印时，您可能希望将结果显示为分数。有了我提出的表示法，它就变得微不足道了。

当然，这对非理性数字没有太大帮助。但您可能希望优化您的计算，使其产生的问题最少（例如，检测sqrt（3）^2等情况）。

对于数学倾向：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这样的测试库

根据@SheetJs的回答，将其组合在一起，我很喜欢：

getCorrection Factor（numberToCheck:number）：数字{var correction Factor：数量=1；if（！Number.isInteger（numberToCheck））{while（！Number.isInteger（numberToCheck））{校正系数*=10；numberToCheck*=校正系数；}}回归修正因子；}

我喜欢带有修正系数的方法，这里是我对ES6和ES5标准的简短决定。与toFixed方法相比，它的优势在于，如果我们想舍入到数百，它不会在数字末尾留下不必要的零，但结果数字是第十个数字：

ES6变体：

// .1 + .2
((a,b,crr) => (a*crr + b*crr)/crr)(.1,.2,100/*correction factor*/);//0.3
// .1 * .2
((a,b,crr) => a*crr*b/crr)(.1,.2,100);//0.02

ES5变体：

// .1 + .2
(function(a,b,crr){ return (a*crr + b*crr)/crr; })(.1,.2,100/*correction factor*/);//0.3
// .1 * .2
(function(a,b,crr){ return a*crr*b/crr; })(.1,.2,100);//0.02

从我的角度来看，这里的想法是将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;
}