Wie rundet man eine Zahl in Javascript auf Zehntel genau auf?

Ich möchte Javascript verwenden, um eine Zahl aufzurunden. Da es sich bei der Zahl um eine Währung handelt, möchte ich, dass sie wie in diesen Beispielen aufgerundet wird (2 Dezimalstellen):

• 192.168 => 192,20
• 192.11 => 192,20
• 192,21 => 192,30
• 192,26 => 192,30
• 192,20 => 192,20

Wie erreicht man dies mit Javascript? Die integrierte Javascript-Funktion rundet die Zahl basierend auf der Standardlogik auf (weniger und mehr als 5 zum Aufrunden).

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

Normales Runden funktioniert mit einer kleinen Änderung:

Math.round(price * 10)/10

und wenn Sie ein Währungsformat beibehalten möchten, können Sie die Zahlenmethode verwenden .toFixed()

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

Obwohl es dadurch zu einem String wird =)

Etwas spät, aber zu diesem Zweck kann eine wiederverwendbare Javascript-Funktion erstellt werden:

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

Rufen Sie die Funktion auf als

alert(roundNumber(192.168,2));

Ganz in der Nähe Das Auge Antwort, aber ich ändere eine Kleinigkeit, damit es funktioniert:

var num = 192.16;
    
console.log(    Math.ceil(num * 10) / 10    );

Das OP erwartet zwei Dinge:
A. auf die höheren Zehntel aufzurunden, und
B. um eine Null an der Hundertstelstelle anzuzeigen (ein typisches Bedürfnis bei Währungen).

Um beide Anforderungen zu erfüllen, scheint für jede der oben genannten Anforderungen eine separate Methode erforderlich zu sein. Hier ist ein Ansatz, der auf der von Suryakiran vorgeschlagenen Antwort aufbaut:

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

Wichtiger Hinweis: Diese Lösung führt bei negativen und exponentiellen Zahlen zu einem ganz anderen Ergebnis.

Um diese Antwort mit zwei sehr ähnlichen Antworten zu vergleichen, sehen Sie sich die folgenden beiden Ansätze an. Beim ersten wird einfach wie üblich auf das nächste Hundertstel gerundet, beim zweiten wird einfach auf das nächste Hundertstel (größer) aufgerundet.

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, das wurde beantwortet, aber ich dachte, Sie möchten vielleicht meine Antwort sehen, die das aufruft math.pow() Funktion einmal. Ich schätze, ich mag es, Dinge trocken zu halten.

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

Es fügt irgendwie alles zusammen. Ersetzen Math.round() mit Math.ceil() Aufrunden statt Abrunden, was das OP wollte.

Diese Funktion begrenzt die Dezimalzahl ohne runde Zahl

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