一个助手函数，其中rounding是默认舍入：

let rounding = 4;

let round = (number) => { let multiply = Math.pow(10,rounding);  return Math.round(number*multiply)/multiply};

console.log(round(0.040579431));

=> 0.0406

这对我（TypeScript）起到了作用：

round(decimal: number, decimalPoints: number): number{
    let roundedValue = Math.round(decimal * Math.pow(10, decimalPoints)) / Math.pow(10, decimalPoints);

    console.log(`Rounded ${decimal} to ${roundedValue}`);
    return roundedValue;
}

样本输出

Rounded 18.339840000000436 to 18.34
Rounded 52.48283999999984 to 52.48
Rounded 57.24612000000036 to 57.25
Rounded 23.068320000000142 to 23.07
Rounded 7.792980000000398 to 7.79
Rounded 31.54157999999981 to 31.54
Rounded 36.79686000000004 to 36.8
Rounded 34.723080000000124 to 34.72
Rounded 8.4375 to 8.44
Rounded 15.666960000000074 to 15.67
Rounded 29.531279999999924 to 29.53
Rounded 8.277420000000006 to 8.28

根据评论中已给出的答案，链接至http://jsfiddle.net/AsRqx/，下面的一个对我来说很好。

function C(num)
{
    return +(Math.round(num + "e+2") + "e-2");
}

function N(num, places)
{
    return +(Math.round(num + "e+" + places) + "e-" + places);
}

C(1.005);

N(1.005, 0);
N(1.005, 1); // Up to 1 decimal places
N(1.005, 2); // Up to 2 decimal places
N(1.005, 3); // Up to 3 decimal places

const formattedNumber=数学舍入（数字*100）/100；

我读过所有的答案，类似问题的答案和最“好”的解决方案的复杂性都让我不满意。我不想放一个大的圆函数集，或者一个小的圆函数，但在科学记数法上失败了。所以，我想出了这个函数。这可能会对我的处境有所帮助：

function round(num, dec) {
   const [sv, ev] = num.toString().split('e');
   return Number(Number(Math.round(parseFloat(sv + 'e' + dec)) + 'e-' + dec) + 'e' + (ev || 0));
}

我没有运行任何性能测试，因为我调用它只是为了更新应用程序的UI。该函数为快速测试提供以下结果：

// 1/3563143 = 2.806510993243886e-7
round(1/3563143, 2)  // returns `2.81e-7`

round(1.31645, 4)    // returns 1.3165

round(-17.3954, 2)   // returns -17.4

这对我来说已经足够了。

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

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