¿Cómo redondear un número en Javascript?

Question

Quiero usar Javascript para redondear un número. Dado que el número es la moneda, lo quiero para redondear para arriba como en estos ejemplos (2 puntos decimales):

• 192,168 =>192,20
• 192,11 =>192,20
• 192,21 =>192,30
• 192,26 =>192,30
• 192,20 =>192.20

¿Cómo conseguir esto usando Javascript? La función incorporada de Javascript redondeará el número basado en la lógica estándar (menos y más de 5 para redondear).

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

redondeo normal trabajará con un pequeño truco:

Math.round(price * 10)/10 

y si desea mantener un formato de moneda, se puede utilizar el método del Número .toFixed()

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

Aunque esto hará que sea a String =)

Answer 3

Muy cerca de respuesta theeye, pero puedo cambiar una pequeña cosa para hacer que funcione:

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

Answer 4

poco tarde pero, puede crear una función de JavaScript reutilizable para este propósito:

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

Llame a la función como

alert(roundNumber(192.168,2)); 

Answer 5

esta decimal límite de función sin número redondo

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

Answer 6

OP espera dos cosas:
A. redondear hasta las décimas más altas, y
B. para mostrar un cero en el lugar de las centésimas (una necesidad típica con la moneda).

Cumplir ambos requisitos parecería necesitar un método separado para cada uno de los anteriores. He aquí un enfoque que se basa en la respuesta sugerida 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 

Nota importante: esta solución produce un resultado muy diferente con los números negativos y exponenciales.

Por el bien de la comparación entre esta respuesta y dos que son muy similares, consulte los 2 enfoques siguientes. El primero simplemente redondea al centésimo más cercano por costumbre, y el segundo simplemente redondea al centésimo más cercano (más grande).

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

bien, esto se ha contestado, pero pensé que le gustaría ver a mi respuesta que llama a la función Math.pow() una vez. Supongo que me gusta mantener las cosas SECAS.

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

Lo pone todo junto. Reemplace Math.round() con Math.ceil() para redondear en lugar de redondear, que es lo que el OP quería.

Answer 8

He estado usando la respuesta de @AndrewMarshall durante mucho tiempo, pero encontré algunos casos extremos. Las siguientes pruebas no supera:

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

Esto es lo que ahora utilizo para tener un comportamiento correcto Round Up:

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

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