我知道有很多答案，但大多数答案在某些特定情况下都有副作用。

没有任何副作用的最简单和最短的解决方案如下：

Number((2.3456789).toFixed(2)) // 2.35

它正确舍入并返回数字而不是字符串

console.log(Number((2.345).toFixed(2)))  // 2.35
console.log(Number((2.344).toFixed(2)))  // 2.34
console.log(Number((2).toFixed(2)))      // 2
console.log(Number((-2).toFixed(2)))     // -2
console.log(Number((-2.345).toFixed(2))) // -2.35

console.log(Number((2.345678).toFixed(3))) // 2.346

var roundUpto = function(number, upto){
    return Number(number.toFixed(upto));
}
roundUpto(0.1464676, 2);

toFixed（2）：这里2是我们要舍入的位数。

如果值是文本类型：

parseFloat("123.456").toFixed(2);

如果值是数字：

var numb = 123.23454;
numb = numb.toFixed(2);

有一个缺点，像1.5这样的值将给出“1.50”作为输出。@minitech建议的修复方法：

var numb = 1.5;
numb = +numb.toFixed(2);
// Note the plus sign that drops any "extra" zeroes at the end.
// It changes the result (which is a string) into a number again (think "0 + foo"),
// which means that it uses only as many digits as necessary.

Math.round似乎是一个更好的解决方案。但事实并非如此！在某些情况下，它不会正确舍入：

Math.round(1.005 * 100)/100 // Returns 1 instead of expected 1.01!

toFixed（）在某些情况下也不会正确舍入（在Chrome v.55.0.2883.87中测试）！

示例：

parseFloat("1.555").toFixed(2); // Returns 1.55 instead of 1.56.
parseFloat("1.5550").toFixed(2); // Returns 1.55 instead of 1.56.
// However, it will return correct result if you round 1.5551.
parseFloat("1.5551").toFixed(2); // Returns 1.56 as expected.

1.3555.toFixed(3) // Returns 1.355 instead of expected 1.356.
// However, it will return correct result if you round 1.35551.
1.35551.toFixed(2); // Returns 1.36 as expected.

我想，这是因为1.555实际上就像是幕后的浮球1.55499994。

解决方案1是使用具有所需舍入算法的脚本，例如：

function roundNumber(num, scale) {
  if(!("" + num).includes("e")) {
    return +(Math.round(num + "e+" + scale)  + "e-" + scale);
  } else {
    var arr = ("" + num).split("e");
    var sig = ""
    if(+arr[1] + scale > 0) {
      sig = "+";
    }
    return +(Math.round(+arr[0] + "e" + sig + (+arr[1] + scale)) + "e-" + scale);
  }
}

它也在Plunker。

注意：这并不是每个人都能通用的解决方案。有几种不同的舍入算法。您的实现可能不同，这取决于您的需求。请参见舍入。

解决方案2是避免前端计算，并从后端服务器提取舍入值。

另一种可能的解决方案，也不是防弹的。

Math.round((num + Number.EPSILON) * 100) / 100

在某些情况下，当您舍入像1.3549999999999998这样的数字时，它将返回错误的结果。它应该是1.35，但结果是1.36。

我尝试了自己的代码。试试看：

function AmountDispalyFormat(value) {
    value = value.toFixed(3);
    var amount = value.toString().split('.');
    var result = 0;
    if (amount.length > 1) {
        var secondValue = parseInt(amount[1].toString().slice(0, 2));
        if (amount[1].toString().length > 2) {
            if (parseInt(amount[1].toString().slice(2, 3)) > 4) {
                secondValue++;
                if (secondValue == 100) {
                    amount[0] = parseInt(amount[0]) + 1;
                    secondValue = 0;
                }
            }
        }

        if (secondValue.toString().length == 1) {
            secondValue = "0" + secondValue;
        }
        result = parseFloat(amount[0] + "." + secondValue);
    } else {
        result = parseFloat(amount);
    }
    return result;
}

对我来说，Math.rround（）没有给出正确的答案。我发现Fixed（2）效果更好。以下是两者的示例：

console.log（数学舍入（43000/80000）*100）；//错误的答案console.log（（（43000/80000）*100）.toFixed（2））；//正确回答

一个简单的通用解决方案

常量舍入=（n，dp）=>{常量h=+（'1'.padEnd（dp+1，'0'））//10或100或1000等return数学舍入（n*h）/h}console.log（“圆形（2.3454，3）”，圆形console.log（“圆形（2.3456，3）”，圆形（2.34563））//2.346console.log（'圆形（2.3456，2）'，圆形（2.34562））//2.35

或者只使用具有相同签名的Lodash圆-例如，_.round（2.3456，2）