Javascript Math.ceil到位置1最近的5

好的

我有很多不受控制的数字要取整：

51255 -> 55000
25 -> 25
9214 -> 9500
13135 -> 15000
25123 -> 30000

我试着将数字修改为字符串和计数长度

但是有没有一种简单的方法可以使用一些数学函数呢？

函数轮（数字）{
function round(number) {
   var numberStr = number + "",
       max,
       i;

   if (numberStr[1] > '4') {
       numberStr[0] = parseInt(numberStr[0]) + 1;
       numberStr[1] = '0';
   } else {
       numberStr[1] = '5';
   }

   for (i = 2; max = numberStr.length; i < max; i += 1) {
      numberStr += '0';
   }

   return parseInt(numberStr);
}

var numberStr=number+“”，
最大值，
我
if（numberStr[1]>'4'）{
numberStr[0]=parseInt（numberStr[0]）+1；
numberStr[1]=“0”；
}否则{
numberStr[1]=“5”；
}
对于（i=2；max=numberStr.length；i

警告：仅适用于自然数

var numbers = [51255, 25, 9214, 13135, 25123, 3, 6];

function weird_round(a) {
    var len = a.toString().length;
    var div = len == 1 ? 1 : Math.pow(10, len - 2);
    return Math.ceil(a / 5 / div) * div * 5;
}

alert(numbers.map(weird_round));

还更新了10以下的数字。对于负数也无法正常工作，如果需要，请提及

---

我不知道为什么，但我认为使用正则表达式会很有趣：

    var result = +(number.toString().replace(/([1-9])([0-9])(.+)/, function() {
        return Math.ceil(+(arguments[1] + '.' + arguments[2])) * 10 - (+arguments[2] < 5?5:0) + arguments[3].replace(/./g, '0');
    }));

var result=+（number.toString（）.replace（/（[1-9]）（[0-9]）（.+）/，function（）{
返回Math.ceil（+（参数[1]+'.+参数[2]）*10-（+参数[2]<5？5:0）+参数[3]。替换（/。/g，'0'）；
}));

---

奇怪的巧合，不久前我写了一些非常相似的东西

function iSuckAtNames(n) {
    var n = n.toString(), len = n.length, res;

    //Check the second number. if it's less than a 5, round down,
    //If it's more/equal, round up

    //Either way, we'll need to use this:
    var res = parseFloat(n[0]) * Math.pow(10, len - 1); //e.g. 5 * 10^4 = 50000
    if (n[1] <= 5) {
        //we need to add a 5 right before the end!
        res += 5 * Math.pow(10, len - 2);
    }
    else {
        //We need another number of that size
        res += Math.pow(10, len - 1);
    }
    return res;
}

函数iSuckAtNames（n）{
var n=n.toString（），len=n.length，res；
//检查第二个数字。如果小于5，则向下取整，
//如果更多/相等，则取整
//无论哪种方式，我们都需要使用：
var res=parseFloat（n[0]）*Math.pow（10，len-1）；//例如5*10^4=50000
if（n[1]这是我迟来的答案。使用no
Math
方法

function toN5( x ) {
    var i = 5;
    while( x >= 100 ) {x/=10; i*=10;}
    return ((~~(x/5))+(x%5?1:0)) * i;
}


演示：


或者这可能更干净一点：

function toN5( x ) {
    var i = 1;
    while( x >= 100 ) {x/=10; i*=10;}
    return (x + (5-((x%5)||5))) * i;
}

演示：

要分解它：

function toN5( x ) {
   //       v---we're going to reduce x to the tens place, and for each place
   //       v       reduction, we'll multiply i * 10 to restore x later.
    var i = 1;

   // as long as x >= 100, divide x by 10, and multiply i by 10.
    while( x >= 100 ) {x/=10; i*=10;}

   // Now round up to the next 5 by adding to x the difference between 5 and
   //    the remainder of x/5 (or if the remainder was 0, we substitute 5
   //    for the remainder, so it is (x + (5 - 5)), which of course equals x).

   // So then since we are now in either the tens or ones place, and we've
   //    rounded to the next 5 (or stayed the same), we multiply by i to restore
   //    x to its original place.
    return (x + (5-((x%5)||5))) * i;
}


或者，为了避免使用逻辑运算符，而只使用算术运算符，我们可以：

return (x + ((5-(x%5))%5)) * i;

把它展开一点：

function toN5( x ) {
    var i = 1;
    while( x >= 100 ) {
        x/=10; 
        i*=10;
    }
    var remainder = x % 5;
    var distance_to_5 = (5 - remainder) % 5;
    return (x + distance_to_5) * i;
}

如果这真的是一个“最接近位置1的5”的上限操作，那么您不想让25去（停留在位置1）吗25？24到25是的，26到30，是的，但在我看来25到25是正确的。是的，我也迷路了。你能描述一下你想要的舍入模式吗？所以你实际上想要1.3个有效数字？我认为25是正确的——舍入到最接近的5。9214是不正确的（应该四舍五入到最接近的500，即9000，而不是9500）。他在问题标题中提到了上限。+1表示使用
toString（）.length
作为一种比log10解决方案更简单的确定数量的方法@mblase75和我这样做了。更新——我的原始解决方案在小于10的数字时失败了。你和我对趣味伴侣的定义不同：）@Phrogz:优雅到底是什么？把一个
函数的所有代码都放在一行上，每次查询对象的
长度
属性，或者在for循环中使用
++i
？我个人认为通过将数字转换成字符串来进行数学运算是“不优雅的”。@Phrogz:好的。但否决票不是为了你喜欢或不喜欢的。我不同意（当然，因为我这么做了）。在极端情况下（这个答案不是），一个“有效”但使用了糟糕或不安全的编码实践的答案应该被否决，而在我看来，应该选择更好的答案。不必要地在数学中使用字符串是非常糟糕的，我会否决。但别担心，你从中得到了同情，所以给你的代表一个净+8：p@Xeon06：她很漂亮，不是吗
return (x + ((5-(x%5))%5)) * i;

function toN5( x ) {
    var i = 1;
    while( x >= 100 ) {
        x/=10; 
        i*=10;
    }
    var remainder = x % 5;
    var distance_to_5 = (5 - remainder) % 5;
    return (x + distance_to_5) * i;
}