要使用定点表示法格式化数字，您可以简单地使用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"

更新：

如今，您可以使用Intl.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方法，该方法在内部将使用IntlAPI：

const format = (num, decimals) => num.toLocaleString('en-US', {
   minimumFractionDigits: 2,      
   maximumFractionDigits: 2,
});


console.log(format(2.005)); // "2.01"
console.log(format(1.345)); // "1.35"

此 API 还为您提供了多种格式化选项，例如千位分隔符、货币符号等。

这是一个古老的话题，但仍然是排名靠前的 Google 结果，并且提供的解决方案共享相同的浮点小数问题。这是我使用的（非常通用的）函数，感谢 MDN：

function round(value, exp) {
  if (typeof exp === 'undefined' || +exp === 0)
    return Math.round(value);

  value = +value;
  exp = +exp;

  if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)));

  // Shift back
  value = value.toString().split('e');
  return +(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp));
}

正如我们所见，我们没有遇到这些问题：

round(1.275, 2);   // Returns 1.28
round(1.27499, 2); // Returns 1.27

这种通用性还提供了一些很酷的东西：

round(1234.5678, -2);   // Returns 1200
round(1.2345678e+2, 2); // Returns 123.46
round("123.45");        // Returns 123

现在，要回答 OP 的问题，必须输入：

round(10.8034, 2).toFixed(2); // Returns "10.80"
round(10.8, 2).toFixed(2);    // Returns "10.80"

或者，对于更简洁、更通用的函数：

function round2Fixed(value) {
  value = +value;

  if (isNaN(value))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + 2) : 2)));

  // Shift back
  value = value.toString().split('e');
  return (+(value[0] + 'e' + (value[1] ? (+value[1] - 2) : -2))).toFixed(2);
}

您可以通过以下方式调用它：

round2Fixed(10.8034); // Returns "10.80"
round2Fixed(10.8);    // Returns "10.80"

各种示例和测试（感谢@tj-crowder！）：

function round(value, exp) {
  if (typeof exp === 'undefined' || +exp === 0)
    return Math.round(value);

  value = +value;
  exp = +exp;

  if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
    return NaN;

  // Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)));

  // Shift back
  value = value.toString().split('e');
  return +(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp));
}
function naive(value, exp) {
  if (!exp) {
    return Math.round(value);
  }
  var pow = Math.pow(10, exp);
  return Math.round(value * pow) / pow;
}
function test(val, places) {
  subtest(val, places);
  val = typeof val === "string" ? "-" + val : -val;
  subtest(val, places);
}
function subtest(val, places) {
  var placesOrZero = places || 0;
  var naiveResult = naive(val, places);
  var roundResult = round(val, places);
  if (placesOrZero >= 0) {
    naiveResult = naiveResult.toFixed(placesOrZero);
    roundResult = roundResult.toFixed(placesOrZero);
  } else {
    naiveResult = naiveResult.toString();
    roundResult = roundResult.toString();
  }
  $("<tr>")
    .append($("<td>").text(JSON.stringify(val)))
    .append($("<td>").text(placesOrZero))
    .append($("<td>").text(naiveResult))
    .append($("<td>").text(roundResult))
    .appendTo("#results");
}
test(0.565, 2);
test(0.575, 2);
test(0.585, 2);
test(1.275, 2);
test(1.27499, 2);
test(1234.5678, -2);
test(1.2345678e+2, 2);
test("123.45");
test(10.8034, 2);
test(10.8, 2);
test(1.005, 2);
test(1.0005, 2);

table {
  border-collapse: collapse;
}
table, td, th {
  border: 1px solid #ddd;
}
td, th {
  padding: 4px;
}
th {
  font-weight: normal;
  font-family: sans-serif;
}
td {
  font-family: monospace;
}

<table>
  <thead>
    <tr>
      <th>Input</th>
      <th>Places</th>
      <th>Naive</th>
      <th>Thorough</th>
    </tr>
  </thead>
  <tbody id="results">
  </tbody>
</table>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

我通常将它添加到我的个人库中，经过一些建议并使用@TIMINeutron 解决方案，然后使其适应十进制长度，这个最适合：

function precise_round(num, decimals) {
   var t = Math.pow(10, decimals);   
   return (Math.round((num * t) + (decimals>0?1:0)*(Math.sign(num) * (10 / Math.pow(100, decimals)))) / t).toFixed(decimals);
}

将适用于报告的异常。

我不知道为什么我不能在以前的答案中添加评论（也许我完全瞎了，我不知道），但我想出了一个使用@Miguel 的答案的解决方案：

function precise_round(num,decimals) {
   return Math.round(num*Math.pow(10, decimals)) / Math.pow(10, decimals);
}

以及它的两条评论（来自@bighostkim 和@Imre）：

• precise_round(1.275,2)不返回 1.28 的问题
• precise_round(6,2)不返回 6.00 的问题（如他所愿）。

我的最终解决方案如下：

function precise_round(num,decimals) {
    var sign = num >= 0 ? 1 : -1;
    return (Math.round((num*Math.pow(10,decimals)) + (sign*0.001)) / Math.pow(10,decimals)).toFixed(decimals);
}

正如你所看到的，我不得不添加一点“更正”（它不是这样，但因为 Math.round 是有损的——你可以在 jsfiddle.net 上检查它——这是我知道如何“修复”的唯一方法“ 它）。它将 0.001 添加到已经填充的数字上，因此它在十进制值的右侧添加了一个13 0。所以使用起来应该是安全的。

之后，我添加.toFixed(decimal)以始终以正确的格式输出数字（具有正确的小数位数）。

差不多就是这样。好好利用它;)

编辑：为负数的“更正”添加了功能。

一种 100% 确定您得到一个带有 2 个小数的数字的方法：

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

如果这会导致舍入错误，您可以使用以下内容，正如 James 在他的评论中所解释的那样：

(Math.round((num * 1000)/10)/100).toFixed(2)