(Math.round((10.2)*100)/100).toFixed(2)

结果应该是10.20

(Math.round((.05)*100)/100).toFixed(2)

结果应该是:0.05

(Math.round((4.04)*100)/100).toFixed(2)

结果应该是:4.04

etc.

要使用定点表示法格式化一个数字，你可以简单地使用toFixed方法:

(10.8).toFixed(2); // "10.80"

var num = 2.4;
alert(num.toFixed(2)); // "2.40"

注意，toFixed()返回一个字符串。

注意:toFixed在90%的情况下不会四舍五入，它会返回四舍五入的值，但在很多情况下，它不起作用。

例如:

2.005.toFixed(2) === "2.00"

更新:

现在，你可以使用国际电话。NumberFormat构造函数。它是ECMAScript国际化API规范(ECMA402)的一部分。它有很好的浏览器支持，甚至包括IE11，并且Node.js完全支持它。

const formatter = new Intl。NumberFormat(“en - us”{ minimumFractionDigits: 2 maximumFractionDigits: 2 })； console.log (formatter.format (2.005));/ /“2.01” console.log (formatter.format (1.345));/ /“1.35”

你也可以使用toLocaleString方法，它会在内部使用Intl API:

const format = (num, decimals) => num. tolocalestring ('en-US'， { minimumFractionDigits: 2 maximumFractionDigits: 2 })； console.log(格式(2.005));/ /“2.01” console.log(格式(1.345));/ /“1.35”

这个API还为您提供了各种格式选项，如千个分隔符、货币符号等。

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);

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

当计算机将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建议舍入到最近邻，与偶数绑定，作为浮点运算的默认行为。这样的修改留给读者练习:)

通过引用使用此响应: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/

@heridev和我用jQuery创建了一个小函数。

接下来你可以试试:

HTML

<input type="text" name="one" class="two-digits"><br>
<input type="text" name="two" class="two-digits">​

jQuery

// apply the two-digits behaviour to elements with 'two-digits' as their class
$( function() {
    $('.two-digits').keyup(function(){
        if($(this).val().indexOf('.')!=-1){         
            if($(this).val().split(".")[1].length > 2){                
                if( isNaN( parseFloat( this.value ) ) ) return;
                this.value = parseFloat(this.value).toFixed(2);
            }  
         }            
         return this; //for chaining
    });
});

​ 在线演示:

http://jsfiddle.net/c4Wqn/