Javascript: arrotondare per eccesso al successivo multiplo di 5

Ho bisogno di una funzione di utilità che assuma un valore intero (compreso tra 2 e 5 cifre di lunghezza) che arrotondi per eccesso al successivo multiplo di 5 anziché al multiplo più vicino di 5. Ecco cosa ho ottenuto:

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

Quando corro round5(32), mi dà 30, dove voglio 35.
Quando corro round5(37), mi dà 35, dove voglio 40.

Quando corro round5(132), mi dà 130, dove voglio 135.
Quando corro round5(137), mi dà 135, dove voglio 140.

eccetera...

Come faccio a fare questo?

Questo farà il lavoro:

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

È solo una variazione dell'arrotondamento comune numberal multiplo più vicino della xfunzione Math.round(number/x)*x, ma usando .ceilinvece di .roundfa sempre arrotondare per eccesso invece che per difetto / per eccesso secondo le regole matematiche.

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

In questo modo il numero verrà arrotondato al 5 più vicino. Per arrotondare sempre al 5 più vicino, utilizzare Math.ceil. Allo stesso modo, per arrotondare sempre per difetto, usa Math.floorinvece di Math.round. Puoi quindi chiamare questa funzione come faresti con qualsiasi altra. Per esempio,

roundToNearest5(21)

sarà di ritorno:

20

Come questo?

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

Sono arrivato qui mentre cercavo qualcosa di simile. Se il mio numero è —0, —1, —2 dovrebbe arrivare a —0, e se è —3, —4, —5 dovrebbe arrivare a —5.

Ho trovato questa soluzione:

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

E i test:

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 ;

Saluti Paul

// round con precisione

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

// arrotondare a 5 con precisione

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

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

motivo per utilizzare round è che l'input previsto può essere un numero casuale.

Grazie!!!

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

può essere?