Javascript: arredondar para o próximo múltiplo de 5

Preciso de uma função de utilidade que receba um valor inteiro (variando de 2 a 5 dígitos de comprimento) que arredonde para o próximo múltiplo de 5 em vez do próximo múltiplo de 5. Aqui está o que consegui:

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

Quando eu corro round5(32), ele me dá 30onde eu quero 35.
Quando eu corro round5(37), ele me dá 35onde eu quero 40.

Quando eu corro round5(132), ele me dá 130onde eu quero 135.
Quando eu corro round5(137), ele me dá 135onde eu quero 140.

etc ...

Como eu faço isso?

Isso fará o trabalho:

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

É apenas uma variação do arredondamento comum numberpara o múltiplo de xfunção mais próximo Math.round(number/x)*x, mas usar em .ceilvez de .roundfaz com que ele sempre arredonde para cima em vez de para baixo / para cima de acordo com as regras matemáticas.

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

Isso arredondará o número para o 5 mais próximo. Para arredondar sempre para o 5 mais próximo, use Math.ceil. Da mesma forma, para sempre arredondar para baixo, use em Math.floorvez de Math.round. Você pode então chamar esta função como faria com qualquer outra. Por exemplo,

roundToNearest5(21)

retornará:

20

Como isso?

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

Cheguei aqui enquanto procurava algo semelhante. Se o meu número for —0, —1, —2, deve ser de —0, e se for —3, —4, —5 deve atingir —5.

Eu encontrei esta solução:

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

E os testes:

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 ;

Atenciosamente Paul

// arredondar com precisão

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

// arredondar para 5 com precisão

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

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

A razão para usar round é que a entrada esperada pode ser um número aleatório.

Obrigado!!!

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

talvez?