Javascript: redondee al siguiente múltiplo de 5

Necesito una función de utilidad que tome un valor entero (de 2 a 5 dígitos de longitud) que se redondea al siguiente múltiplo de 5 en lugar del múltiplo más cercano de 5. Esto es lo que obtuve:

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

Cuando corro round5(32), me da 30, donde quiero 35.
Cuando corro round5(37), me da 35, donde quiero 40.

Cuando corro round5(132), me da 130, donde quiero 135.
Cuando corro round5(137), me da 135, donde quiero 140.

etc ...

¿Cómo hago esto?

Esto hará el trabajo:

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

Es solo una variación del redondeo común numberal múltiplo de xfunción más cercano Math.round(number/x)*x, pero usar en .ceillugar de .roundhace que siempre se redondee hacia arriba en lugar de hacia abajo / hacia arriba de acuerdo con las reglas matemáticas.

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

Esto redondeará el número al 5 más cercano. Para redondear siempre al 5 más cercano, utilice Math.ceil. Del mismo modo, para redondear siempre hacia abajo, utilice en Math.floorlugar de Math.round. A continuación, puede llamar a esta función como lo haría con cualquier otra. Por ejemplo,

roundToNearest5(21)

volverá:

20

¿Me gusta esto?

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

Llegué aquí buscando algo similar. Si mi número es —0, —1, —2, debería bajar a —0, y si es —3, —4, —5 debería bajar a —5.

Se me ocurrió esta solución:

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

Y las pruebas:

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 ;

Saludos Paul

// redondear con precisión

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

// redondear a 5 con precisión

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

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

La razón para usar round es que la entrada esperada puede ser un número aleatorio.

¡¡¡Gracias!!!

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

¿tal vez?