Comment arrondir un nombre en Javascript?

Je veux utiliser Javascript pour arrondir un nombre. Depuis, le nombre est de la monnaie, je veux qu'il rond comme dans ces exemples (2 décimales):

  • 192.168 => 192.20
  • 192.11 => 192.20
  • 192.21 => 192.30
  • 192.26 => 192.30
  • 192.20 => 192.20

Comment réaliser cela à l'aide de Javascript? Intégré dans la fonction Javascript va arrondir le nombre basé sur le standard de la logique (moins et plus de 5 pour arrondir).

InformationsquelleAutor cyberfly | 2011-03-04
  1. 289
    /**
 * @param num The number to round
 * @param precision The number of decimal places to preserve
 */
function roundUp(num, precision) {
  precision = Math.pow(10, precision)
  return Math.ceil(num * precision) / precision
}

roundUp(192.168, 1) //=> 192.2
    • quel est le but de la multiplication, puis en divisant par 10?
    • Si vous ne le faites pas, alors ceil() vous donnera 193, donc nous devons nous assurer que toute la précision que nous voulons garder est avant la virgule. Puis nous avons fait l'opération inverse afin de rétablir l ' “original” de la valeur.
    • Si vous obtenez un certain nombre comme 192.19999999999997, vous pouvez appliquer .toFixed(1) à la num
    • Et pour ceux ici en se demandant comment faire pour arrondir au nombre ENTIER le plus proche, vous avez juste besoin de faire des Mathématiques.ceil(). Le reste est juste de traiter avec des décimales. Pour sauver les autres le temps qu'il a fallu que mon cerveau pour arriver à ça!
    • Cette solution a un bug: les Maths.ceil(0.0159 * 1000000000) / précision. Vous obtiendrez une fraction 0.015900001. Besoin d'ajouter une gamme de validation pour la précision.
    InformationsquelleAutor Andrew Marshall
  2. 26

    Peu en retard mais, peut créer une réutilisables fonction javascript à cet effet:

    //Arguments: number to round, number of decimal places
function roundNumber(rnum, rlength) { 
    var newnumber = Math.round(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
    return newnumber;
}

    Appeler la fonction comme

    alert(roundNumber(192.168,2));
    • Cela fonctionne très bien, mais l'OP demande comment arrondir un nombre, afin de Mathématiques.ceil devrait être utilisé ici à la place de Mathématiques.la ronde.
    • Cette réponse est meilleure que la accepté de répondre si vous êtes à la recherche d'arrondir correctement en dépit de ce qui décimale que vous visez. Ex: 1.054 --> 1.05 1.055 --> 1.06 CEPENDANT ici est un cas limite: 1.005 --> 1 1.006 --> 1.01 ET 1.015 --> 1.01 1.016 --> 1.02 Donc être prudent.
    InformationsquelleAutor suryakiran
  3. 19

    Normal arrondissement de travail avec un petit tweak:

    Math.round(price * 10)/10

    et si vous voulez garder un format de devise, vous pouvez utiliser la méthode du Numéro .toFixed()

    (Math.round(price * 10)/10).toFixed(2)

    Bien que ce sera une Chaîne =)

    • Les mathématiques.round(192.11 * 100)/100 -> 192.11
    • La deuxième partie de l'arrondi, c'est plus comme price.toFixed(2)
    • oups, Merci pour la capture de que. J'ai mal lu la question. Réponse de mise à jour.
    • L'OP a demandé comment arrondir un nombre, afin de Mathématiques.ceil devrait être utilisé ici à la place de Mathématiques.la ronde.
    InformationsquelleAutor Shad
  4. 9

    Très près à TheEye réponse, mais j'ai changer un peu la chose pour le faire fonctionner:

    JS:

    var num = 192.16;
    
console.log(    Math.ceil(num * 10) / 10    );

    InformationsquelleAutor Hoàng Long
  5. 2

    L'OP attend deux choses:

    A. à arrondir à la hausse des dixièmes, et

    B. pour afficher un zéro dans les centièmes place (typique d'un besoin avec de la monnaie).

    Répondant à la fois à l'exigence semble nécessiter une méthode distincte pour chacun des ci-dessus. Voici une approche qui s'appuie sur suryakiran de la proposition de réponse: 

    //Arguments: number to round, number of decimal places.

function roundPrice(rnum, rlength) {
    var newnumber = Math.ceil(rnum * Math.pow(10, rlength-1)) / Math.pow(10, rlength-1);
    var toTenths = newnumber.toFixed(rlength);
    return toTenths;
}

alert(roundPrice(678.91011,2)); //returns 679.00
alert(roundPrice(876.54321,2)); //returns 876.60

    Note importante: cette solution produit un résultat très différent et le négatif exponentielle des nombres.

    Pour les besoins de la comparaison entre cette réponse et deux qui sont très similaires, voir les 2 approches. Le premier simplement arrondit au centième le plus proche par habitude, et la seconde, tout simplement arrondi au centième le plus proche (le plus grand).

    function roundNumber(rnum, rlength) { 
    var newnumber = Math.round(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
    return newnumber;
}

alert(roundNumber(678.91011,2)); //returns 678.91

function ceilNumber(rnum, rlength) { 
    var newnumber = Math.ceil(rnum * Math.pow(10, rlength)) / Math.pow(10, rlength);
    return newnumber;
}

alert(ceilNumber(678.91011,2)); //returns 678.92
    InformationsquelleAutor Kay V
  6. 2

    ok, ce qui a été répondu, mais j'ai pensé que vous aimeriez voir ma réponse qui appelle les mathématiques.fonction pow() une fois. Je suppose que j'aime garder les choses SÈCHES.

    function roundIt(num, precision) {
    var rounder = Math.pow(10, precision);
    return (Math.round(num * rounder) / rounder).toFixed(precision)
};

    Il met tout cela ensemble. Remplacer Les Mathématiques.round() avec les Mathématiques.ceil() pour un aller-vers le haut au lieu de l'arrondissement, qui est ce que l'OP voulait.

    InformationsquelleAutor John Grabauskas
  7. 1

    cette fonction limite décimale sans numéro de la ronde

    function limitDecimal(num,decimal){
     return num.toString().substring(0, num.toString().indexOf('.')) + (num.toString().substr(num.toString().indexOf('.'), decimal+1));
}
    • Comme la petite alternative: return ( " + num ).split('.').maj()
    • merci Roberto ce code fonctionne, mais supprimer toutes les décimales
    InformationsquelleAutor Behnam Mohammadi
  8. 1

    J'ai été en utilisant @AndrewMarshall réponse pendant une longue période, mais a trouvé des cas limites. Les tests suivants ne passe pas:

    equals(roundUp(9.69545, 4), 9.6955);
equals(roundUp(37.760000000000005, 4), 37.76);
equals(roundUp(5.83333333, 4), 5.8333);

    Voici ce que j'utilise maintenant pour avoir round up se comporter correctement:

    //Closure
(function() {
/**
* Decimal adjustment of a number.
*
* @param {String}  type  The type of adjustment.
* @param {Number}  value The number.
* @param {Integer} exp   The exponent (the 10 logarithm of the adjustment base).
* @returns {Number} The adjusted value.
*/
function decimalAdjust(type, value, exp) {
//If the exp is undefined or zero...
if (typeof exp === 'undefined' || +exp === 0) {
return Math[type](value);
}
value = +value;
exp = +exp;
//If the value is not a number or the exp is not an integer...
if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
return NaN;
}
//If the value is negative...
if (value < 0) {
return -decimalAdjust(type, -value, exp);
}
//Shift
value = value.toString().split('e');
value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
//Shift back
value = value.toString().split('e');
return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
}
//Decimal round
if (!Math.round10) {
Math.round10 = function(value, exp) {
return decimalAdjust('round', value, exp);
};
}
//Decimal floor
if (!Math.floor10) {
Math.floor10 = function(value, exp) {
return decimalAdjust('floor', value, exp);
};
}
//Decimal ceil
if (!Math.ceil10) {
Math.ceil10 = function(value, exp) {
return decimalAdjust('ceil', value, exp);
};
}
})();
//Round
Math.round10(55.55, -1);   //55.6
Math.round10(55.549, -1);  //55.5
Math.round10(55, 1);       //60
Math.round10(54.9, 1);     //50
Math.round10(-55.55, -1);  //-55.5
Math.round10(-55.551, -1); //-55.6
Math.round10(-55, 1);      //-50
Math.round10(-55.1, 1);    //-60
Math.round10(1.005, -2);   //1.01 -- compare this with Math.round(1.005*100)/100 above
Math.round10(-1.005, -2);  //-1.01
//Floor
Math.floor10(55.59, -1);   //55.5
Math.floor10(59, 1);       //50
Math.floor10(-55.51, -1);  //-55.6
Math.floor10(-51, 1);      //-60
//Ceil
Math.ceil10(55.51, -1);    //55.6
Math.ceil10(51, 1);        //60
Math.ceil10(-55.59, -1);   //-55.5
Math.ceil10(-59, 1);       //-50

    Source: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round

    • Vos cas de test semble incorrect. roundUp(37.760000000000005, 4) devrait être 37.7601, et roundUp(5.83333333, 4) devrait être 5.8334. Ces deux (et la première) tous vrai pour le fn, je fournis.
    InformationsquelleAutor Nicolas BADIA
  9. 0

    parseInt toujours arrondi vers le bas soo.....

    JS:

    console.log(parseInt(5.8)+1);

    ne parseInt()+1

    • Cela ne fonctionne que si 5.0 doens existe pas
    InformationsquelleAutor Omar