Javascript: zaokrąglij w górę do następnej wielokrotności 5

Potrzebuję funkcji narzędzia, która przyjmuje wartość całkowitą (od 2 do 5 cyfr długości), która zaokrągla w górę do następnej wielokrotności 5 zamiast najbliższej wielokrotności 5. Oto, co otrzymałem:

function round5(x)
{
    return (x % 5) >= 2.5 ? parseInt(x / 5) * 5 + 5 : parseInt(x / 5) * 5;
}

Kiedy biegnę round5(32), to daje mi 30, gdzie chcę 35.
Kiedy biegam round5(37), daje mi 35, gdzie chcę 40.

Kiedy biegnę round5(132), daje mi to 130, gdzie chcę 135.
Kiedy biegam round5(137), daje mi to 135, gdzie chcę 140.

itp...

Jak mam to zrobic?

To wystarczy:

function round5(x)
{
    return Math.ceil(x/5)*5;
}

Jest to tylko odmiana zwykłego zaokrąglania numberdo najbliższej wielokrotności xfunkcji Math.round(number/x)*x, ale użycie .ceilzamiast .roundpowoduje, że zawsze zaokrągla w górę zamiast w dół / w górę zgodnie z zasadami matematycznymi.

const roundToNearest5 = x => Math.round(x/5)*5

Zaokrągli to liczbę do najbliższej 5. Aby zawsze zaokrąglić w górę do najbliższej 5, użyj Math.ceil. Podobnie, aby zawsze zaokrąglić w dół, użyj Math.floorzamiast Math.round. Możesz wtedy wywołać tę funkcję, tak jak każdą inną. Na przykład,

roundToNearest5(21)

wróci:

20

Lubię to?

function roundup5(x) { return (x%5)?x-x%5+5:x }

Przyjechałem tutaj, szukając czegoś podobnego. Jeśli mój numer to –0, –1, –2, powinien dochodzić do –0, a ​​jeśli jest –3, –4, –5, powinien sięgać –5.

Wymyśliłem takie rozwiązanie:

function round(x) { return x%5<3 ? (x%5===0 ? x : Math.floor(x/5)*5) : Math.ceil(x/5)*5 }

A testy:

for (var x=40; x<51; x++) {
  console.log(x+"=>", x%5<3 ? (x%5===0 ? x : Math.floor(x/5)*5) : Math.ceil(x/5)*5)
}
// 40 => 40
// 41 => 40
// 42 => 40
// 43 => 45
// 44 => 45
// 45 => 45
// 46 => 45
// 47 => 45
// 48 => 50
// 49 => 50
// 50 => 50

voici 2 solutions possibles :
y= (x % 10==0) ? x : x-x%5 +5; //......... 15 => 20 ; 37 => 40 ;  41 => 45 ; 20 => 20 ; 

z= (x % 5==0) ? x : x-x%5 +5;  //......... 15 => 15 ; 37 => 40 ;  41 => 45 ; 20 => 20 ;

Pozdrawiam Paul

// okrągłe z precyzją

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

// precyzyjnie zaokrąglij do 5

var round5 = (value, precision) => {
    return round(value * 2, precision) / 2;
}

const fn = _num =>{
    return Math.round(_num)+ (5 -(Math.round(_num)%5))
}

powodem używania round jest to, że oczekiwane dane wejściowe mogą być liczbą losową.

Dzięki!!!

if( x % 5 == 0 ) {
    return int( Math.floor( x / 5 ) ) * 5;
} else {
    return ( int( Math.floor( x / 5 ) ) * 5 ) + 5;
}

może?