看看固定点算法。如果你想操作的数字范围很小（例如货币），它可能会解决你的问题。我会将其舍入为几个十进制值，这是最简单的解决方案。

你只是在做乘法吗？如果是这样的话，那么你可以利用一个关于十进制算术的简单秘密。即NumberOfDecimals（X）+NumberOfDecimals（Y）=预期的NumberOf小数。也就是说，如果我们有0.123*0.12，那么我们知道会有5位小数，因为0.123有3位小数，0.12有2位小数。因此，如果JavaScript给我们一个像0.014760000002这样的数字，我们可以安全地四舍五入到小数点后的第五位，而不用担心丢失精度。

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

浮点值编程缺乏精度

在不同的编程语言中，浮点值编程缺乏精度是一个已知的问题。Javascript是使用浮点值进行数学运算时遇到问题的一种。这种问题主要是由于这些编程语言实现的浮点数的内存二进制表示。

让我们希望编程语言、编译器、硬件开发人员和工程师能够一次性解决这些问题，至少解决1024个浮点数字。。。也许这将足以让99.999%的其他开发人员在下一个世纪的编程中感到安心。。。

一种可能的解决方案：转换为整数，计算，然后返回

一种可能的解决方案是将浮点数转换为整数，执行计算，然后将结果转换回浮点数。这似乎在大多数时候都有效。原则上：

函数测试（）{变量x=0.1*0.2；//原始方法变量y=（（0.1*10）*（0.2*10））/100；//可行的解决方案document.write（x+'<br>'+y）；}测试（）；

当然，在需要的情况下，可以相应地调整功能，例如：

函数测试（）{变量x=0.12*0.23；//原始方法变量y=（（0.12*100）*（0.23*100））/10000；//可行的解决方案document.write（x+'<br>'+y）；}测试（）；

它也可以是自动化的：

函数myToInt（v）{设i=1；设r；而（r%1！=0）{i=i*10；r=v*i；}返回[r，i]；}函数测试（）{设x=0.11111111；设y=0.22222222；设a=x*y；//原始方法[x，i]=myToInt（x）；[y，j]=myToInt（y）；设d=i*j；设b=x*y/d；//另一种可行的解决方案console.log（a+'\n'+b）document.write（a+'<br>'+b）；}测试（）；

考虑到这一点，我们可以这样做：

函数myToInt（v）{设i=1；设r；而（r%1！=0）{i=i*10；r=v*i；}返回[r，i]；}函数测试（）{设x=14898设y=10.8设z=100设a=x*y/z；//原始方法[y，i]=myToInt（y）；设b=（x*y）/（z*i）；//另一种可行的解决方案console.log（a+'\n'+b）document.write（a+'<br>'+b）；}测试（）；

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

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

非常简单））

首先将两个数字都设为整数，执行表达式，然后对结果进行除法运算，以返回小数点：

function evalMathematicalExpression(a, b, op) {
    const smallest = String(a < b ? a : b);
    const factor = smallest.length - smallest.indexOf('.');

    for (let i = 0; i < factor; i++) {
        b *= 10;
        a *= 10;
    }

    a = Math.round(a);
    b = Math.round(b);
    const m = 10 ** factor;
    switch (op) {
        case '+':
            return (a + b) / m;
        case '-':
            return (a - b) / m;
        case '*':
            return (a * b) / (m ** 2);
        case '/':
            return a / b;
    }

    throw `Unknown operator ${op}`;
}

几个操作的结果（排除的数字是eval的结果）：

0.1 + 0.002   = 0.102 (0.10200000000000001)
53 + 1000     = 1053 (1053)
0.1 - 0.3     = -0.2 (-0.19999999999999998)
53 - -1000    = 1053 (1053)
0.3 * 0.0003  = 0.00009 (0.00008999999999999999)
100 * 25      = 2500 (2500)
0.9 / 0.03    = 30 (30.000000000000004)
100 / 50      = 2 (2)