Comment arrondir un nombre en Javascript?


159

Je veux utiliser Javascript pour arrondir un nombre. Puisque le nombre est une devise, je veux qu'il arrondisse 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 y parvenir en utilisant Javascript? La fonction Javascript intégrée arrondira le nombre en fonction de la logique standard (moins et plus de 5 pour arrondir).

Réponses:


313
/**
 * @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

2
@AndrewMarshall Quel est le but de multiplier, puis de diviser par 10?
codecowboy

6
@codecowboy Si vous ne le faites pas, alors ceil()vous le donnera 193, nous devons donc nous assurer que toute la précision que nous voulons conserver est avant le point décimal. Ensuite, nous faisons l'opération inverse afin de restaurer la valeur «d'origine».
Andrew Marshall

1
Si vous obtenez un certain nombre comme 192.19999999999997, vous pouvez postuler .toFixed(1)aunum
flamer.ohr

4
Et pour ceux qui se demandent ici comment arrondir au nombre ENTIER le plus proche, il vous suffit de Math.ceil (). Le reste ne concerne que les nombres décimaux. Pour sauver les autres le temps qu'il a fallu à mon cerveau pour y arriver!
Nigel B.Peck

Cette solution a un bogue: Math.ceil (0.0159 * 1000000000) / precision. Vous obtiendrez une fraction 0.015900001. Besoin d'ajouter une validation de plage pour la précision.
Frank

26

Peu de retard mais, peut créer une fonction javascript réutilisable à 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;
}

Appelez la fonction comme

alert(roundNumber(192.168,2));

2
Cela fonctionne très bien, mais l'OP a demandé comment arrondir un nombre, donc Math.ceil devrait être utilisé ici au lieu de Math.round.
kloddant le

Cette réponse est meilleure que la réponse acceptée si vous cherchez à arrondir correctement quelle que soit la décimale que vous visez. Ex: 1.054 -> 1.05 1.055 -> 1.06 CEPENDANT voici un cas de bord: 1.005 -> 1 1.006 -> 1.01 AND 1.015 -> 1.01 1.016 -> 1.02 Alors soyez prudent.
Jay K

21

L'arrondi normal fonctionnera avec une petite modification:

Math.round(price * 10)/10

et si vous souhaitez conserver un format de devise, vous pouvez utiliser la méthode Number .toFixed()

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

Bien que cela en fasse une chaîne =)


Math.round (192.11 * 100) / 100 -> 192.11
krtek

1
Le second n'a pas besoin d'être arrondi, c'est plus commeprice.toFixed(2)
Michael Krelin - hacker

@Krtek ooops, merci d'avoir attrapé ça. J'ai mal lu la question. Réponse mise à jour.
Shad

2
L'OP a demandé comment arrondir un nombre, donc Math.ceil devrait être utilisé ici au lieu de Math.round.
kloddant

10

Très proche de la réponse TheEye , mais je change un petit truc pour le faire fonctionner:

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


2

Le PO attend deux choses:
A. arrondir au dixième supérieur, et
B. afficher un zéro à la place des centièmes (un besoin typique avec une devise).

Répondre à ces deux exigences semblerait nécessiter une méthode distincte pour chacun des éléments ci-dessus. Voici une approche qui s'appuie sur la réponse suggérée de suryakiran:

//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

Remarque importante: cette solution produit un résultat très différent avec des nombres négatifs et exponentiels.

Dans un souci de comparaison entre cette réponse et deux qui sont très similaires, voir les 2 approches suivantes. Le premier arrondit simplement au centième le plus proche comme d'habitude, et le second arrondit simplement au centième le plus proche (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

2

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

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

Cela met tout en place. Remplacez Math.round () par Math.ceil () pour arrondir au lieu d'arrondir, ce que voulait l'OP.


1

cette fonction limite décimale sans nombre rond

function limitDecimal(num,decimal){
     return num.toString().substring(0, num.toString().indexOf('.')) + (num.toString().substr(num.toString().indexOf('.'), decimal+1));
}

Comme alternative plus courte: return ('' + num) .split ('.'). Shift ()
Roberto

merci Roberto ce code fonctionne, mais supprimez tous les décimaux
Behnam Mohammadi

0

J'utilise la réponse @AndrewMarshall depuis longtemps, mais j'ai trouvé des cas extrêmes. Les tests suivants ne réussissent 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 que le round se comporte 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


1
Vos cas de test semblent incorrects. roundUp(37.760000000000005, 4)devrait être 37.7601et roundUp(5.83333333, 4)devrait être 5.8334. Ces deux (et le vôtre) sont tous valables pour le fn que j'ai fourni.
Andrew Marshall

@AndrewMarshall a raison, vos valeurs attendues sont fausses pour les cas 2 et 3.
Amn le

-3

parseInt arrondit toujours à la baisse soo .....

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

faire parseInt () + 1

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.