Javascript: la formattazione di un numero arrotondato per N decimali

Question

in JavaScript, il tipico modo per arrotondare un numero di cifre decimali N è qualcosa di simile:

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

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

console.log(roundNumber(0.1 + 0.2, 2));
console.log(roundNumber(2.1234, 2));

Tuttavia questo approccio attorno ad un massima di N cifre decimali, mentre io voglio sempre round per N cifre decimali. Ad esempio, "2.0" sarebbe arrotondato a "2".

Tutte le idee?

Answer 1

Questa non è una ploblem arrotondamento, che è un problema di visualizzazione. Un numero non contiene informazioni su cifre significative; il valore 2 è lo stesso di 2,0000 miliardi. E 'quando si accende il valore arrotondato in una stringa che avete rendono visualizzare un certo numero di cifre.

Si può solo aggiungere zeri 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 internazionali del client utilizza periodo come separatore decimale, il codice ha bisogno di un po 'più lavoro a funzionare per altre impostazioni.)

Answer 2

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

è sufficiente scrivere:

var myNumber = 2;

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

:

ecc ...

Answer 3

Ho trovato un modo. Questo è un 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 di ripetere un carattere utilizzando un array costruttore qui se sei curioso di sapere perché ho aggiunto il "+ 1".

Answer 4

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

var number = 51.93999999999761;

Mi piacerebbe avere quattro cifre di precisione: 51.94

basta fare:

number.toPrecision(4);

il risultato sarà: 51.94

Answer 5

PHP-Like arrotondamento Metodo

Il seguente codice può essere utilizzato per aggiungere la tua versione di Math.round al tuo spazio dei nomi che prende un parametro di precisione. Diversamente decimale arrotondamento nell'esempio di cui sopra, questa esegue alcuna conversione da e stringhe, e il parametro di precisione funziona allo stesso modo come PHP e Excel cui un positivo 1 sarebbe arrotondare a 1 decimale e -1 sarebbe intorno 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

Mozilla Developer riferimento per Math.round ()

Answer 6

Speriamo che il codice di lavoro (non ha fatto molto di 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;
}

Answer 7

Questo funziona per arrotondare a N cifre (se si desidera solo per troncare per N cifre rimuovere la chiamata Math.round e utilizzare il Math.trunc uno):

function roundN(value, digits) {
   var tenToN = 10 ** digits;
   return /*Math.trunc*/(Math.round(value * tenToN)) / tenToN;
}

ha dovuto ricorrere a tale logica a Java in passato, quando ero authoring manipolazione dei dati componenti E-Slate . Cioè da quando avevo scoperto che l'aggiunta di 0,1 volte a 0 che ci si finisce con una certa parte inaspettatamente lunga decimali (questo è dovuto al galleggiamento aritmetica in virgola).

Un commento utente in formato per mostrare sempre 2 decimali posti chiama questa scala tecnica.

Alcuni menzione ci sono casi che non lo fanno tondo come previsto e al http: //www.jacklmoore.com/notes/rounding-in-javascript/ ciò è suggerito invece:

function round(value, decimals) {
  return Number(Math.round(value+'e'+decimals)+'e-'+decimals);
}

Answer 8

Ecco un link ad uno sprintf 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

Fa che aiutano?

Answer 9

Credo che al di sotto di funzione può 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); tornerà 600.23

Answer 10

Se non si ha realmente a cuore l'arrotondamento, appena aggiunto un toFixed (x) e poi la rimozione 0ES di traino 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;
}