Javascript: formattare un numero arrotondato a N decimali

in JavaScript, il modo tipico per arrotondare un numero a N decimali è qualcosa come:

function round_number(num, dec) { return Math.round(num * Math.pow(10, dec)) / Math.pow(10, dec); } 

Tuttavia questo approccio si arrotonderà a un massimo di N decimali mentre voglio sempre arrotondare a N decimali. Ad esempio “2.0” verrebbe arrotondato a “2”.

Qualche idea?

Questo non è un problema di arrotondamento, è un problema di visualizzazione. Un numero non contiene informazioni su cifre significative; il valore 2 è uguale a 2.0000000000000. È quando si trasforma il valore arrotondato in una stringa in cui è ansible visualizzare un determinato numero di cifre.

Potresti aggiungere zero dopo il numero, qualcosa come:

 var s = number.toString(); if (s.indexOf('.') == -1) s += '.'; while (s.length < s.indexOf('.') + 4) s += '0'; 

(Si noti che questo presuppone che le impostazioni regionali del client utilizzino il periodo come separatore decimale, il codice richiede un po 'più di lavoro per funzionare per altre impostazioni.)

Penso che ci sia un approccio più semplice a tutti dato qui, ed è il metodo Number.toFixed() già implementato in JavaScript.

semplicemente scrivi:

 var myNumber = 2; myNumber.toFixed(2); //returns "2.00" myNumber.toFixed(1); //returns "2.0" 

eccetera…

Ho trovato un modo. Questo è il codice di Christoph con una correzione:

 function toFixed(value, precision) { var precision = precision || 0, power = Math.pow(10, precision), absValue = Math.abs(Math.round(value * power)), result = (value < 0 ? '-' : '') + String(Math.floor(absValue / power)); if (precision > 0) { var fraction = String(absValue % power), padding = new Array(Math.max(precision - fraction.length, 0) + 1).join('0'); result += '.' + padding + fraction; } return result; } 

Leggi i dettagli della ripetizione di un personaggio usando un costruttore di array qui se sei curioso di sapere perché ho aggiunto il “+ 1”.

C’è sempre un modo migliore per fare le cose.

 var number = 51.93999999999761; 

Vorrei ottenere una precisione di quattro cifre: 51,94

basta fare:

 number.toPrecision(4); 

il risultato sarà: 51.94

Metodo di arrotondamento simile a PHP

Il seguente codice può essere utilizzato per aggiungere la propria versione di Math.round al proprio spazio dei nomi che utilizza un parametro di precisione. A differenza dell’arrotondamento decimale nell’esempio precedente, questo non esegue alcuna conversione da e verso le stringhe e il parametro di precisione funziona allo stesso modo di PHP ed Excel, in cui un 1 positivo passerebbe a 1 decimale e -1 sarebbe arrotondato alle decine.

 var myNamespace = {}; myNamespace.round = function(number, precision) { var factor = Math.pow(10, precision); var tempNumber = number * factor; var roundedTempNumber = Math.round(tempNumber); return roundedTempNumber / factor; }; myNamespace.round(1234.5678, 1); // 1234.6 myNamespace.round(1234.5678, -1); // 1230 

da Mozilla Developer reference per Math.round ()

Spero che il codice funzionante (non ha fatto molti test):

 function toFixed(value, precision) { var precision = precision || 0, neg = value < 0, power = Math.pow(10, precision), value = Math.round(value * power), integral = String((neg ? Math.ceil : Math.floor)(value / power)), fraction = String((neg ? -value : value) % power), padding = new Array(Math.max(precision - fraction.length, 0) + 1).join('0'); return precision ? integral + '.' + padding + fraction : integral; } 

Ecco un link a uno sprint di Javascript,

http://www.webtoolkit.info/javascript-sprintf.html

Una chiamata a sprintf () è una metodologia di arrotondamento in perl, ma javascript non ha questa funzione in modo nativo.

http://perldoc.perl.org/functions/sprintf.html

Questo aiuta?

Penso che la funzione qui sotto possa aiutare

 function roundOff(value,round) { return (parseInt(value * (10 ** (round + 1))) - parseInt(value * (10 ** round)) * 10) > 4 ? (((parseFloat(parseInt((value + parseFloat(1 / (10 ** round))) * (10 ** round))))) / (10 ** round)) : (parseFloat(parseInt(value * (10 ** round))) / ( 10 ** round)); } 

utilizzo: roundOff(600.23458,2); restituirà 600.23

Se non ti interessa veramente l’arrotondamento, aggiungi un toFixed (x) e poi rimuovi gli 0es finali e il punto se necessario. Non è una soluzione veloce.

 function format(value, decimals) { if (value) { value = value.toFixed(decimals); } else { value = "0"; } if (value.indexOf(".") < 0) { value += "."; } var dotIdx = value.indexOf("."); while (value.length - dotIdx <= decimals) { value += "0"; } // add 0's return value; }