Question

我一直在C＃中使用Math.Round(myNumber, MidpointRounding.ToEven)来进行服务器端舍入，但是，用户需要知道“实时”服务器端操作的结果是什么意思（避免使用{{ 3}} request）创建一个JavaScript方法来复制C＃使用的MidpointRounding.ToEven方法。

MidpointRounding.ToEven是Gaussian / Ajax，这是一种非常常见的会计系统舍入方法banker's rounding。

有没有人有这方面的经验？我在网上找到了例子，但它们没有舍入到给定的小数位数......

Answer 1

function evenRound(num, decimalPlaces) {
    var d = decimalPlaces || 0;
    var m = Math.pow(10, d);
    var n = +(d ? num * m : num).toFixed(8); // Avoid rounding errors
    var i = Math.floor(n), f = n - i;
    var e = 1e-8; // Allow for rounding errors in f
    var r = (f > 0.5 - e && f < 0.5 + e) ?
                ((i % 2 == 0) ? i : i + 1) : Math.round(n);
    return d ? r / m : r;
}

console.log( evenRound(1.5) ); // 2
console.log( evenRound(2.5) ); // 2
console.log( evenRound(1.535, 2) ); // 1.54
console.log( evenRound(1.525, 2) ); // 1.52

现场演示：http://jsfiddle.net/NbvBp/

对于看起来更严格的处理（我从未使用过），你可以尝试这个BigNumber实现。

Answer 2

接受的答案会绕到给定数量的地方。在此过程中，它调用toFixed将数字转换为字符串。由于价格昂贵，我提供以下解决方案。它将以0.5结尾的数字舍入到最接近的偶数。它不会处理到任意数量的位置。

function even_p(n){
  return (0===(n%2));
};

function bankers_round(x){
    var r = Math.round(x);
    return (((((x>0)?x:(-x))%1)===0.5)?((even_p(r))?r:(r-1)):r);
};

Answer 3

这是@soegaard的一个很好的解决方案。这是一个小改动，使其适用于小数点：

bankers_round(n:number, d:number=0) {
    var x = n * Math.pow(10, d);
    var r = Math.round(x);
    var br = (((((x>0)?x:(-x))%1)===0.5)?(((0===(r%2)))?r:(r-1)):r);
    return br / Math.pow(10, d);
}

在此期间 - 这里有一些测试：

console.log(" 1.5 -> 2 : ", bankers_round(1.5) );
console.log(" 2.5 -> 2 : ", bankers_round(2.5) );
console.log(" 1.535 -> 1.54 : ", bankers_round(1.535, 2) );
console.log(" 1.525 -> 1.52 : ", bankers_round(1.525, 2) );

console.log(" 0.5 -> 0 : ", bankers_round(0.5) );
console.log(" 1.5 -> 2 : ", bankers_round(1.5) );
console.log(" 0.4 -> 0 : ", bankers_round(0.4) );
console.log(" 0.6 -> 1 : ", bankers_round(0.6) );
console.log(" 1.4 -> 1 : ", bankers_round(1.4) );
console.log(" 1.6 -> 2 : ", bankers_round(1.6) );

console.log(" 23.5 -> 24 : ", bankers_round(23.5) );
console.log(" 24.5 -> 24 : ", bankers_round(24.5) );
console.log(" -23.5 -> -24 : ", bankers_round(-23.5) );
console.log(" -24.5 -> -24 : ", bankers_round(-24.5) );

Answer 4

这是不寻常的堆栈溢出，其底部答案优于接受的答案。刚刚清理了@xims解决方案并使其更加清晰：

function bankersRound(n, d=2) {
    var x = n * Math.pow(10, d);
    var r = Math.round(x);
    var br = Math.abs(x) % 1 === 0.5 ? (r % 2 === 0 ? r : r-1) : r;
    return br / Math.pow(10, d);
}

Answer 5

const isEven = (value: number) => value % 2 === 0;
const isHalf = (value: number) => {
    const epsilon = 1e-8;
    const remainder = Math.abs(value) % 1;

    return remainder > .5 - epsilon && remainder < .5 + epsilon;
};

const roundHalfToEvenShifted = (value: number, factor: number) => {
    const shifted = value * factor;
    const rounded = Math.round(shifted);
    const modifier = value < 0 ? -1 : 1;

    return !isEven(rounded) && isHalf(shifted) ? rounded - modifier : rounded;
};

const roundHalfToEven = (digits: number, unshift: boolean) => {
    const factor = 10 ** digits;

    return unshift
        ? (value: number) => roundHalfToEvenShifted(value, factor) / factor
        : (value: number) => roundHalfToEvenShifted(value, factor);
};

const roundDollarsToCents = roundHalfToEven(2, false);
const roundCurrency = roundHalfToEven(2, true);

如果您不喜欢调用toFixed（）的开销
希望能够提供任意规模
不想引入浮点错误
想拥有可读，可重用的代码

roundHalfToEven是一个生成固定比例舍入函数的函数。为了避免引入FPE，我以美分而不是美元进行货币操作。存在unshift参数是为了避免进行这些操作而再次移动的开销。

Answer 6

严格地说，所有这些实现都应该处理要舍入的负数位数的情况。

这是一个边缘情况，但仍然明智地禁止它（或者非常清楚这意味着什么，例如-2正在四舍五入到最接近的数百个）。

高斯/银行家在JavaScript中的四舍五入

6 个答案: