Comment arrondir un nombre en Javascript?

Question

Je veux utiliser Javascript pour arrondir un nombre. Étant donné que le nombre est monnaie, je veux qu'il arrondir comme dans ces exemples (2 points décimaux):

• 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 arrondit le nombre selon la logique standard (moins et plus de 5 à arrondir).

Answer 1

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

Answer 2

l'arrondissement normal travaillera avec un petit tweak:

Math.round(price * 10)/10 

et si vous voulez garder un format de monnaie, vous pouvez utiliser le numéro de méthode .toFixed()

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

Bien que cela rendra a String =)

Answer 3

Très près de réponse TheEye, mais je change une petite chose pour le faire fonctionner:

<script type="text/javascript"> 
var num = 192.16; 
num = Math.ceil(num * 10)/10; 
alert(num); 
</script> 

Answer 4

un peu tard, mais, peut créer une réutilisable 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; 
} 

Appelez la fonction

alert(roundNumber(192.168,2)); 

Answer 5

cette décimale limite de fonction sans nombre rond

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

Answer 6

L'OP s'attend à deux choses:
A. pour arrondir aux dixièmes supérieurs, et
B. pour montrer un zéro dans la place de centièmes (un besoin typique avec la devise).

Répondre aux deux exigences semblerait nécessiter une méthode distincte pour chacun de ces éléments. Voici une approche qui se fonde 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 

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

À titre 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 par habitude, et le second arrondit simplement au centième le plus proche.

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 

Answer 7

ok, cela a été répondu, mais je pensais que vous aimeriez voir ma réponse qui appelle une fois la fonction Math.pow(). 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) 
}; 

En quelque sorte, tout est réuni. Remplacez Math.round() par Math.ceil() pour arrondir au lieu d'arrondir, ce que souhaitait l'OP.

Answer 8

J'utilise @AndrewMarshall pour répondre depuis longtemps, mais j'ai 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 d'avoir un comportement tour 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