Javascript: formattazione di un numero arrotondato in N decimali

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

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 arrotonderà a un massimo di N cifre decimali mentre voglio sempre arrotondare a N cifre 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 sulle cifre significative; il valore 2 è uguale a 2.0000000000000. È quando trasformi il valore arrotondato in una stringa che devi fargli visualizzare un certo numero di cifre.

Potresti semplicemente 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 ciò presuppone che le impostazioni internazionali del client utilizzino il punto come separatore decimale, il codice necessita di ulteriore lavoro per funzionare per altre impostazioni.)

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

scrivi semplicemente:

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 sulla ripetizione di un carattere 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 codice seguente può essere utilizzato per aggiungere la propria versione di Math.round al proprio spazio dei nomi che accetta un parametro di precisione. A differenza dell'arrotondamento decimale nell'esempio sopra, non esegue alcuna conversione da e verso stringhe e il parametro di precisione funziona allo stesso modo di PHP ed Excel, in cui un 1 positivo arrotonda a 1 cifra decimale e -1 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

dal riferimento per sviluppatori Mozilla per Math.round ()

Si spera che il codice funzioni (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;
}

Penso che sotto la funzione 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);tornerà600.23

Questo funziona per l'arrotondamento a N cifre (se vuoi solo troncare a N cifre rimuovi la chiamata Math.round e usa quella Math.trunc):

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

Ho dovuto ricorrere a tale logica in Java in passato quando stavo creando componenti E-Slate per la manipolazione dei dati . Questo da quando ho scoperto che aggiungendo 0.1 molte volte a 0 si otterrebbe una parte decimale inaspettatamente lunga (questo è dovuto all'aritmetica in virgola mobile).

Un commento dell'utente al numero di formato per mostrare sempre 2 cifre decimali chiama questa tecnica di ridimensionamento.

Alcuni menzionano che ci sono casi che non vengono arrotondati come previsto e su http://www.jacklmoore.com/notes/rounding-in-javascript/ viene invece suggerito:

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

Se non ti interessa davvero l'arrotondamento, aggiungi semplicemente un toFixed (x) e quindi rimuovi gli 0 finali e il punto se necessario. Non è una soluzione rapida.

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