es6接受答案版本:

function round(value, precision) {
    const multiplier = 10 ** (precision || 0);
    return Math.round(value * multiplier) / multiplier;
}

试试这个:

var original=28.453

// 1.- round "original" to two decimals
var result = Math.round (original * 100) / 100  //returns 28.45

// 2.- round "original" to 1 decimal
var result = Math.round (original * 10) / 10  //returns 28.5

// 3.- round 8.111111 to 3 decimals
var result = Math.round (8.111111 * 1000) / 1000  //returns 8.111

不那么复杂，更容易实现……

有了这个，你可以创建一个函数来做:

function RoundAndFix (n, d) {
    var m = Math.pow (10, d);
    return Math.round (n * m) / m;
}

函数RoundAndFix (n, d) { var m =数学。Pow (10, d); 返回数学。圆(n * m) / m; ｝ console.log (RoundAndFix(8.111111, 3));

编辑:看这个如何四舍五入使用四舍五入一半。四舍五入模式是我们大多数人在小学时学到的

数学。Round (num * 10) / 10工作，这里是一个例子…

var number = 12.3456789
var rounded = Math.round(number * 10) / 10
// rounded is 12.3

如果你想让它有一个小数点，即使它是0，然后加…

var fixed = rounded.toFixed(1)
// fixed is always to 1 d.p.
// NOTE: .toFixed() returns a string!

// To convert back to number format
parseFloat(number.toFixed(2))
// 12.34
// but that will not retain any trailing zeros

// So, just make sure it is the last step before output,
// and use a number format during calculations!

编辑:添加圆与精度功能…

使用这个原理，作为参考，这里有一个方便的小圆函数，它需要精度…

function round(value, precision) {
    var multiplier = Math.pow(10, precision || 0);
    return Math.round(value * multiplier) / multiplier;
}

．.． 使用……

round(12345.6789, 2) // 12345.68
round(12345.6789, 1) // 12345.7

．.． 默认舍入到最接近的整数(精度为0)…

round(12345.6789) // 12346

．.． 可以四舍五入到最接近的10或100等…

round(12345.6789, -1) // 12350
round(12345.6789, -2) // 12300

．.． 正确处理负数……

round(-123.45, 1) // -123.4
round(123.45, 1) // 123.5

．.． 并且可以与toFixed结合使用，以一致的格式作为字符串…

round(456.7, 2).toFixed(2) // "456.70"

我投票给toFixed()，但是，为了记录，这里有另一种使用位移位将数字转换为int的方法。因此，它总是趋近于零(正数向下，负数向上)。

var rounded = ((num * 10) << 0) * 0.1;

但是，嘿，因为没有函数调用，它非常快。：）

这里有一个使用字符串匹配:

var rounded = (num + '').replace(/(^.*?\d+)(\.\d)?.*/, '$1$2');

我不建议使用字符串变体，只是说。

通常，十进制舍入是通过缩放完成的:round(num * p) / p

天真的实现

使用下面带有中间数的函数，您将得到预期的上四舍五入值，或者有时根据输入得到下四舍五入值。

这种舍入不一致可能会在客户端代码中引入难以检测的错误。

函数naiveRound(num, decimalPlaces) { var p =数学。decimalPlaces战俘(10日); 返回数学。Round (num * p) / p; } console.log(naiveRound(1.245, 2));// 1.25 correct(四舍五入) console.log(naiveRound(1.255, 2));// 1.25不正确(应该是1.26)

更好的实现

通过将数字转换为指数表示法中的字符串，正数将按预期四舍五入。 但是要注意，负数四舍五入和正数四舍五入是不同的。

事实上，它的执行基本上相当于“四舍五入”的规则，您将看到round(-1.005, 2)的计算结果为-1，即使round(1.005, 2)的计算结果为1.01。lodash _。圆法使用这种技术。

/** * Round half up ('round half towards positive infinity') * Uses exponential notation to avoid floating-point issues. * Negative numbers round differently than positive numbers. */ function round(num, decimalPlaces) { num = Math.round(num + "e" + decimalPlaces); return Number(num + "e" + -decimalPlaces); } // test rounding of half console.log( round(0.5, 0) ); // 1 console.log( round(-0.5, 0) ); // 0 // testing edge cases console.log( round(1.005, 2) ); // 1.01 console.log( round(2.175, 2) ); // 2.18 console.log( round(5.015, 2) ); // 5.02 console.log( round(-1.005, 2) ); // -1 console.log( round(-2.175, 2) ); // -2.17 console.log( round(-5.015, 2) ); // -5.01

如果希望在负数舍入时保持通常的行为，则需要在调用Math.round()之前将负数转换为正数，然后在返回之前将它们转换回负数。

// Round half away from zero
function round(num, decimalPlaces) {
    num = Math.round(Math.abs(num) + "e" + decimalPlaces) * Math.sign(num);
    return Number(num + "e" + -decimalPlaces);
}

有一种不同的纯数学技术来执行舍入到最近(使用“舍入到离零一半远的地方”)，在调用舍入函数之前应用epsilon校正。

简单地说，我们添加最小的浮动值(= 1.0 ulp;单位在最后的位置)到数字之前舍入。这将移动到数字之后的下一个可表示的值，远离零。

/** * Round half away from zero ('commercial' rounding) * Uses correction to offset floating-point inaccuracies. * Works symmetrically for positive and negative numbers. */ function round(num, decimalPlaces) { var p = Math.pow(10, decimalPlaces); var e = Number.EPSILON * num * p; return Math.round((num * p) + e) / p; } // test rounding of half console.log( round(0.5, 0) ); // 1 console.log( round(-0.5, 0) ); // -1 // testing edge cases console.log( round(1.005, 2) ); // 1.01 console.log( round(2.175, 2) ); // 2.18 console.log( round(5.015, 2) ); // 5.02 console.log( round(-1.005, 2) ); // -1.01 console.log( round(-2.175, 2) ); // -2.18 console.log( round(-5.015, 2) ); // -5.02

这是为了抵消十进制数编码过程中可能出现的隐式舍入误差，特别是十进制数的最后一个位置有“5”的数字，如1.005、2.675和16.235。实际上，十进制系统中的1.005在64位二进制浮点数中被编码为1.0049999999999999;而十进制系统中的1234567.005被编码为64位二进制浮点的1234567.0049999998882413。

值得注意的是，二进制舍入误差的最大值取决于(1)数字的大小和(2)相对机器的ε(2^-52)。

Lodash有一个循环方法:

_.round(4.006);
// => 4

_.round(4.006, 2);
// => 4.01

_.round(4060, -2);
// => 4100

文档。

源。