2009-10-12 6 views
19

Je veux convertir tous les nombres à .25tour à .25 le plus proche javascript

le plus proche ... Alors

5 becomes 5.00 
2.25 becomes 2.25 
4 becomes 4.00 
3.5 becomes 3.50 

Merci

+14

Aucune tentative de votre côté? – random

+4

Cette question ne semble pas avoir de sens. Tous vos chiffres sont en train de devenir eux-mêmes, il n'y a pas d'arrondi. – Barmar

Répondre

71

est ici une implémentation de ce rslite dit:

var number = 5.12345; 
number = (Math.round(number * 4)/4).toFixed(2); 
+1

Travailler également en Java - merci. – Fedearne

+3

@Fearearne: C'est plutôt un problème arithmétique qu'un problème de langage. – Gumbo

+1

Ici c'est comme une fonction: var roundNearQtr = fonction (nombre) { return (Math.round (nombre * 4)/4).àFixer (2); }; – spesic

56

Multiplier par 4, Arrondir à l'entier, diviser par 4 et le format avec deux décimales.

Modifier Quel est le motif des sous-cotations? Laissez au moins un commentaire pour savoir ce qui devrait être amélioré.

+2

Pourquoi cela a-t-il été déprécié? C'est la bonne réponse, après tout. – Duroth

+0

Merci! Je me demandais la même chose ... – rslite

+0

+1: C'est bon pour moi aussi. – Steve

9

Si la vitesse est votre préoccupation, notez que vous pouvez obtenir une amélioration de la vitesse de 30% en utilisant:

var nearest = 4; 
var rounded = number + nearest/2 - (number+nearest/2) % nearest; 

De mon site: http://phrogz.net/round-to-nearest-via-modulus-division
Tests de performance ici: http://jsperf.com/round-to-nearest

+0

Grande réponse ... Changer pour cette si vous avez des nombres négatifs. Var arrondi = nombre + plus proche/2 - Math.abs ((nombre + plus proche/2)% le plus proche); – Lenny

+0

@Lenny Mais notez que lorsque vous faites cela, vous appelez un appel de fonction ('Math.abs') et ainsi vous perdrez le gain de vitesse. – Phrogz

0

Une très bonne approximation pour ro inancement:

function Rounding (number, precision){ 

    var newNumber; 
    var sNumber = number.toString(); 

    var increase = precision + sNumber.length - sNumber.indexOf('.') + 1; 

    if (number < 0) 
    newNumber = (number - 5 * Math.pow(10,-increase)); 
    else 
    newNumber = (number + 5 * Math.pow(10,-increase)); 

    var multiple = Math.pow(10,precision); 
    return Math.round(newNumber * multiple)/multiple; 
} 
+0

Comment est-ce mieux que les autres réponses? Les autres semblent beaucoup plus courts. (Je pourrais analyser le code pour essayer de comprendre quel avantage il a, mais il est plus rapide de le demander.^_ ^) – Venryx

1

est ici @ La réponse de Gumbo sous une forme d'une fonction:

var roundNearQtr = function(number) { 
    return (Math.round(number * 4)/4).toFixed(2); 
}; 

Vous pouvez maintenant faire des appels:

roundNearQtr(5.12345); // 5.00 
roundNearQtr(3.23); // 3.25 
roundNearQtr(3.13); // 3.25 
roundNearQtr(3.1247); // 3.00 
8

Voici une fonction générique pour faire l'arrondi. Dans les exemples ci-dessus, 4 a été utilisé parce que c'est dans l'inverse de .25. Cette fonction permet à l'utilisateur d'ignorer ce détail. Il ne prend pas actuellement en charge la précision prédéfinie, mais cela peut facilement être ajouté.

function roundToNearest(numToRound, numToRoundTo) { 
    numToRoundTo = 1/(numToRoundTo); 

    return Math.round(numToRound * numToRoundTo)/numToRoundTo; 
} 
+1

Cela nécessite une opération supplémentaire que 'Math.round (num/multiple) * multiple; '. * Cependant *, c'est ma version préférée pour une raison majeure: elle ne donne pas des résultats comme "0.3000000000000004" pour "Round (.2 + .1, .1)". – Venryx

0

Utilisez la fonction ci-dessous, espère que cela aide

function roundByQuarter(value) { 
    var inv = 1.0/0.25; 
    return Math.round(value * inv)/inv; 
} 

Appelez la fonction ci-dessous, entraînera la valeur du quartier le plus proche, qui est il ne reviendra pas .32, .89, .56, mais le sera renvoie .25, .75, .50 décimales seulement.

roundByQuarter(2.74) = 2.75 

roundByQuarter(2.34) = 2.25 

roundByQuarter(2.94) = 3.00 

roundByQuarter(2.24) = 2.25 
0
function roundToInc(num, inc) { 
    const diff = num % inc; 
    return diff>inc/2?(num-diff+inc):num-diff; 
} 

> roundToInc(233223.2342343, 0.01) 
233223.23 
> roundToInc(505, 5) 
505 
> roundToInc(507, 5) 
505 
> roundToInc(508, 5) 
510 
Questions connexes