这项看似简单的任务面临的最大挑战是，我们希望它能够产生心理预期的结果，即使输入包含最小的舍入误差（更不用说计算中会出现的误差）。如果我们知道实际结果正好是1.005，那么我们预计舍入到两位数会得到1.01，即使1.005是一个带有大量舍入误差的大型计算的结果。

当处理floor（）而不是round（）时，问题变得更加明显。例如，当删除33.3点后面的最后两位数字后的所有内容时，我们肯定不会期望得到33.29，但这就是结果：

console.log（数学楼层（33.3*100）/100）

在简单的情况下，解决方案是对字符串而不是浮点数执行计算，从而完全避免舍入错误。然而，这个选项在第一次非平凡的数学运算（包括大多数除法运算）时失败，而且速度很慢。

当对浮点数进行操作时，解决方案是引入一个参数，该参数指定我们愿意偏离实际计算结果的量，以便输出心理预期的结果。

var round=函数（num，数字=2，compensateErrors=2）{如果（num<0）{return this.round（-num，数字，compensateErrors）；}const pow=数学.pow（10，数字）；return（数学舍入（num*pow*（1+compensateErrors*Number.EPSILON））/pow）；}/*---测试---*/console.log（“本线程中提到的边缘案例：”）var值=[0.015，1.005，5.555，156893.145，362.42499999999995，1.275，1.277499，1.2345678e+2，2.175，5.015，58.9*0.15]；值。对于每个（（n）=>{console.log（n+“->”+圆（n））；console.log（-n+“->”+圆形（-n））；});console.log（“\n对于太大以至于无法在计算精度范围内执行舍入的数字，只有基于字符串的计算才有帮助。”）console.log（“标准：”+圆形（1e+19））；console.log（“补偿=1:”+圆（1e+19，2，1））；console.log（“有效无补偿：”+round（1e+19，2，0.4））；

注意：Internet Explorer不知道Number.EPSILON。如果您仍然需要支持它，那么您可以使用垫片，或者自己定义特定浏览器系列的常量。

精确的舍入方法。来源：Mozilla

(function(){

    /**
     * Decimal adjustment of a number.
     *
     * @param   {String}    type    The type of adjustment.
     * @param   {Number}    value   The number.
     * @param   {Integer}   exp     The exponent (the 10 logarithm of the adjustment base).
     * @returns {Number}            The adjusted value.
     */
    function decimalAdjust(type, value, exp) {
        // If the exp is undefined or zero...
        if (typeof exp === 'undefined' || +exp === 0) {
            return Math[type](value);
        }
        value = +value;
        exp = +exp;
        // If the value is not a number or the exp is not an integer...
        if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
            return NaN;
        }
        // Shift
        value = value.toString().split('e');
        value = Math[type](+(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));
    }

    // Decimal round
    if (!Math.round10) {
        Math.round10 = function(value, exp) {
            return decimalAdjust('round', value, exp);
        };
    }
    // Decimal floor
    if (!Math.floor10) {
        Math.floor10 = function(value, exp) {
            return decimalAdjust('floor', value, exp);
        };
    }
    // Decimal ceil
    if (!Math.ceil10) {
        Math.ceil10 = function(value, exp) {
            return decimalAdjust('ceil', value, exp);
        };
    }
})();

示例：

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
Math.round10(1.005, -2); // 1.01 -- compare this with Math.round(1.005*100)/100 above
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50

number=(parseInt((number +0.005)*100))/100;     

如果要正常舍入（2位小数），请添加0.005

8.123 +0.005=> 8.128*100=>812/100=>8.12   

8.126 +0.005=> 8.131*100=>813/100=>8.13   

舍入问题可以通过使用指数表示法来避免。

public roundFinancial(amount: number, decimals: number) {
    return Number(Math.round(Number(`${amount}e${decimals}`)) + `e-${decimals}`);
}

这个答案更关乎速度。

var precalculatedPrecisions = [1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10];

function round(num, _prec) {
    _precision = precalculatedPrecisions[_prec]
    return Math.round(num * _precision + 1e-14) / _precision ;
}

jsPerf关于这一点。

这对我（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