Javascript: arrondir au multiple supérieur de 5

J'ai besoin d'une fonction utilitaire qui prend une valeur entière (allant de 2 à 5 chiffres de longueur) qui arrondit au prochain multiple de 5 au lieu du multiple le plus proche de 5. Voici ce que j'ai obtenu:

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

Quand je cours round5(32), ça me donne 30là où je veux 35.
Quand je cours round5(37), ça me donne 35là où je veux 40.

Quand je cours round5(132), ça me donne 130où je veux 135.
Quand je cours round5(137), ça me donne 135où je veux 140.

etc...

Comment puis-je faire cela?

Cela fera le travail:

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

C'est juste une variation de l'arrondi commun numberau multiple le plus proche de la xfonction Math.round(number/x)*x, mais utiliser .ceilau lieu de le .roundfait toujours arrondir au lieu de bas / haut selon des règles mathématiques.

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

Cela arrondira le nombre au 5 le plus proche. Pour toujours arrondir au 5 le plus proche, utilisez Math.ceil. De même, pour toujours arrondir vers le bas, utilisez Math.floorplutôt que Math.round. Vous pouvez alors appeler cette fonction comme vous le feriez pour n'importe quelle autre. Par exemple,

roundToNearest5(21)

retournera:

20

Comme ça?

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

Je suis arrivé ici en cherchant quelque chose de similaire. Si mon nombre est —0, —1, —2, il devrait passer à —0, et s'il est —3, —4, —5, il devrait plafonner à —5.

J'ai trouvé cette solution:

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

Et les tests:

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 ;

Cordialement Paul

// rond avec précision

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

// arrondi à 5 avec précision

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

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

La raison d'utiliser round est que l'entrée attendue peut être un nombre aléatoire.

Merci!!!

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

peut être?