Come arrotondare un numero in Javascript?

Voglio usare Javascript per arrotondare un numero. Poiché il numero è la valuta, lo voglio arrotondare come in questi esempi (2 punti decimali):

  • 192.168 => 192,20
  • 192.11 => 192,20
  • 192.21 => 192.30
  • 192.26 => 192.30
  • 192.20 => 192.20

Come ottenere ciò usando Javascript? La funzione Javascript integrata arrotonda il numero in base alla logica standard (meno e più di 5 per arrotondare).

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

Poco tardi ma, può creare una funzione javascript riutilizzabile per questo scopo:

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

Chiama la funzione come

 alert(roundNumber(192.168,2)); 

L’arrotondamento normale funzionerà con un piccolo aggiustamento:

 Math.round(price * 10)/10 

e se si desidera mantenere un formato di valuta, è ansible utilizzare il metodo .toFixed()

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

Anche se questo lo renderà una stringa =)

Molto vicino alla risposta di TheEye, ma cambio una piccola cosa per farlo funzionare:

  

Il PO si aspetta due cose:
A. per arrotondare fino ai decimi più alti, e
B. per mostrare uno zero al centesimo posto (un bisogno tipico con valuta).

Soddisfare entrambi i requisiti sembrerebbe richiedere un metodo separato per ciascuno dei precedenti. Ecco un approccio che si basa sulla risposta suggerita da 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: questa soluzione produce un risultato molto diverso con numeri negativi ed esponenziali.

Per motivi di comparazione tra questa risposta e due che sono molto simili, vedere i seguenti 2 approcci. Il primo si limita semplicemente al centesimo più vicino al solito, e il secondo semplicemente arrotonda al centesimo più vicino (più 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 

ok, è stata data una risposta, ma ho pensato che ti sarebbe piaciuto vedere la mia risposta che chiama la funzione math.pow () una volta. Immagino che mi piaccia mantenere le cose ASCIUTTE.

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

In un certo senso mette tutto insieme. Sostituisci Math.round () con Math.ceil () per arrotondare, invece di arrotondare, che è ciò che l’OP voleva.

questa funzione decimale limite senza numero tondo

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

Ho usato la risposta @AndrewMarshall per un lungo periodo, ma ho trovato alcuni casi limite. I seguenti test non superano:

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

Ecco cosa ora utilizzo per avere un comportamento corretto correttamente:

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

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