通过引用使用此响应:https://stackoverflow.com/a/21029698/454827

我建立了一个函数来获得动态的小数数:

function toDec(num, dec)
{
        if(typeof dec=='undefined' || dec<0)
                dec = 2;

        var tmp = dec + 1;
        for(var i=1; i<=tmp; i++)
                num = num * 10;

        num = num / 10;
        num = Math.round(num);
        for(var i=1; i<=dec; i++)
                num = num / 10;

        num = num.toFixed(dec);

        return num;
}

这里的工作示例:https://jsfiddle.net/wpxLduLc/

将以下内容放在全局范围内:

Number.prototype.getDecimals = function ( decDigCount ) {
   return this.toFixed(decDigCount);
}

然后试试:

var a = 56.23232323;
a.getDecimals(2); // will return 56.23

更新

请注意，toFixed()只能适用于0-20之间的小数，即a.g getdecimals(25)可能会生成一个javascript错误，所以为了适应，你可以添加一些额外的检查，即。

Number.prototype.getDecimals = function ( decDigCount ) {
   return ( decDigCount > 20 ) ? this : this.toFixed(decDigCount);
}

toFixed(n)提供小数点后的n个长度;toPrecision (x) 总长度为x。

使用下面的方法

// Example: toPrecision(4) when the number has 7 digits (3 before, 4 after)
    // It will round to the tenths place
    num = 500.2349;
    result = num.toPrecision(4); // result will equal 500.2

如果你想要固定的号码，可以使用

result = num.toFixed(2);

这很简单，和其他方法一样有效:

function parseNumber(val, decimalPlaces) {
    if (decimalPlaces == null) decimalPlaces = 0
    var ret = Number(val).toFixed(decimalPlaces)
    return Number(ret)
}

由于toFixed()只能在数字上调用，并且不幸地返回一个字符串，因此它在两个方向上为您完成所有解析。你可以传递一个字符串或一个数字，每次你都会得到一个数字!调用parseNumber(1.49)将返回1，而调用parseNumber(1.49,2)将返回1.50。就像他们中最好的一样!

浮点值的问题在于，它们试图用固定数量的比特表示无限数量的(连续的)值。所以自然地，在游戏中一定会有一些损失，你会被一些价值观咬伤。

当计算机将1.275存储为浮点值时，它实际上不会记住它是1.275还是1.27499999999999993，甚至是1.27500000000000002。这些值在四舍五入到两个小数后应该会给出不同的结果，但它们不会，因为对于计算机来说，它们存储为浮点值后看起来完全相同，并且没有办法恢复丢失的数据。任何进一步的计算只会积累这样的不精确性。

因此，如果精度很重要，就必须从一开始就避免使用浮点值。最简单的选择是

使用专门的图书馆 使用字符串存储和传递值(附带字符串操作) 使用整数(例如，你可以传递实际值的百分之一，例如，用美分代替美元)

例如，当使用整数存储百分位数时，查找实际值的函数非常简单:

function descale(num, decimals) {
    var hasMinus = num < 0;
    var numString = Math.abs(num).toString();
    var precedingZeroes = '';
    for (var i = numString.length; i <= decimals; i++) {
        precedingZeroes += '0';
    }
    numString = precedingZeroes + numString;
    return (hasMinus ? '-' : '') 
        + numString.substr(0, numString.length-decimals) 
        + '.' 
        + numString.substr(numString.length-decimals);
}

alert(descale(127, 2));

对于字符串，你需要四舍五入，但它仍然是可控的:

function precise_round(num, decimals) {
    var parts = num.split('.');
    var hasMinus = parts.length > 0 && parts[0].length > 0 && parts[0].charAt(0) == '-';
    var integralPart = parts.length == 0 ? '0' : (hasMinus ? parts[0].substr(1) : parts[0]);
    var decimalPart = parts.length > 1 ? parts[1] : '';
    if (decimalPart.length > decimals) {
        var roundOffNumber = decimalPart.charAt(decimals);
        decimalPart = decimalPart.substr(0, decimals);
        if ('56789'.indexOf(roundOffNumber) > -1) {
            var numbers = integralPart + decimalPart;
            var i = numbers.length;
            var trailingZeroes = '';
            var justOneAndTrailingZeroes = true;
            do {
                i--;
                var roundedNumber = '1234567890'.charAt(parseInt(numbers.charAt(i)));
                if (roundedNumber === '0') {
                    trailingZeroes += '0';
                } else {
                    numbers = numbers.substr(0, i) + roundedNumber + trailingZeroes;
                    justOneAndTrailingZeroes = false;
                    break;
                }
            } while (i > 0);
            if (justOneAndTrailingZeroes) {
                numbers = '1' + trailingZeroes;
            }
            integralPart = numbers.substr(0, numbers.length - decimals);
            decimalPart = numbers.substr(numbers.length - decimals);
        }
    } else {
        for (var i = decimalPart.length; i < decimals; i++) {
            decimalPart += '0';
        }
    }
    return (hasMinus ? '-' : '') + integralPart + (decimals > 0 ? '.' + decimalPart : '');
}

alert(precise_round('1.275', 2));
alert(precise_round('1.27499999999999993', 2));

注意，这个函数舍入到最近邻，与零绑定，而IEEE 754建议舍入到最近邻，与偶数绑定，作为浮点运算的默认行为。这样的修改留给读者练习:)

您还可以使用. toprecision()方法和一些自定义代码，无论int部分的长度如何，始终四舍五入到十进制第n位。

function glbfrmt (number, decimals, seperator) {
    return typeof number !== 'number' ? number : number.toPrecision( number.toString().split(seperator)[0].length + decimals);
}

你也可以让它成为一个插件，以便更好地使用。