web-dev-qa-db-fra.com

Comment arrondir un nombre en Javascript?

Je veux utiliser Javascript pour arrondir un nombre. Comme le nombre est une devise, je veux le arrondir comme dans ces exemples (2 décimales):

  • 192.168 => 192.2
  • 192.11 => 192.2
  • 192.21 => 192.
  • 192.26 => 192.
  • 192.20 => 192.2

Comment y parvenir en utilisant Javascript? La fonction Javascript intégrée arrondira le nombre en fonction de la logique standard (moins de 5 et plus de 5 à arrondir).

javascriptrounding
153
cyberfly
/**
 * @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
292
Andrew Marshall

Un peu tard, 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 en tant que

alert(roundNumber(192.168,2));
26
suryakiran

L'arrondissement normal fonctionnera avec un petit tweak:

Math.round(price * 10)/10

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

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

Bien que cela en fasse un String =)

19
Shad

Très près de TheEye répondre, mais je change une petite chose pour que cela fonctionne:

var num = 192.16;
    
console.log(    Math.ceil(num * 10) / 10    );
9
Hoàng Long

ok, cela a été répondu, mais je pensais que vous voudriez peut-être voir ma réponse qui appelle la fonction math.pow () une fois. Je suppose que j'aime garder les choses au sec.

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

Cela met le tout ensemble. Remplacez Math.round () par Math.ceil () pour arrondir au lieu d'arrondir, comme le voulait le PO.

2
John Grabauskas

Le PO attend deux choses:
UNE. arrondir aux dixièmes les plus élevés, et
B. afficher un zéro à la centième (un besoin typique avec de la monnaie).

Répondre aux deux exigences semble nécessiter une méthode distincte pour chacune des solutions ci-dessus. Voici une approche qui s'appuie sur la réponse suggérée par 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.

Aux fins de comparaison entre cette réponse et deux réponses très similaires, voir les 2 approches suivantes. Le premier arrondit simplement au centième le plus proche par 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
Kay V

J'utilise @AndrewMarshall answer depuis longtemps, mais j'ai trouvé des cas Edge. Les tests suivants ne passent 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 faire arrondir 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
Nicolas BADIA

cette fonction limite décimale sans nombre arrondi

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

parseInt arrondit toujours soo .....

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

faire parseInt () + 1

0
Omar