Wie runde ich eine Zahl in Javascript auf?

159

Ich möchte Javascript verwenden, um eine Zahl aufzurunden. Da die Zahl Währung ist, 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 das mit Javascript? Die integrierte Javascript-Funktion rundet die Zahl basierend auf der Standardlogik auf (weniger und mehr als 5 zum Aufrunden).

Cyberfly
quelle

Antworten:

313
/**
 * @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
Andrew Marshall
quelle
2
@ AndrewMarshall, was ist der Zweck des Multiplizierens und anschließenden Dividierens durch 10?
Codecowboy
6
@codecowboy Wenn Sie dies nicht tun, ceil()geben Sie 193es uns. Wir müssen also sicherstellen, dass die Genauigkeit, die wir beibehalten möchten, vor dem Dezimalpunkt liegt. Dann machen wir die inverse Operation, um den "ursprünglichen" Wert wiederherzustellen.
Andrew Marshall
1
Wenn Sie eine Nummer wie erhalten 192.19999999999997, können Sie sich .toFixed(1)bei dernum
flamer.ohr
4
Und für diejenigen, die sich hier fragen, wie sie auf die nächste GANZE Zahl aufrunden können, benötigen Sie nur Math.ceil (). Der Rest ist nur mit Dezimalstellen zu tun. Um anderen die Zeit zu sparen, die mein Gehirn dafür brauchte!
Nigel B. Peck
Diese Lösung hat Fehler: Math.ceil (0.0159 * 1000000000) / Genauigkeit. Sie erhalten einen Bruchteil 0.015900001. Für die Genauigkeit muss eine Bereichsvalidierung hinzugefügt werden.
Frank
26

Wenig spät, kann aber eine wiederverwendbare Javascript-Funktion für diesen Zweck erstellen:

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

alert(roundNumber(192.168,2));
Suryakiran
quelle
2
Dies funktioniert hervorragend, aber das OP hat gefragt, wie eine Zahl aufgerundet werden soll. Daher sollte hier Math.ceil anstelle von Math.round verwendet werden.
Kloddant
Diese Antwort ist besser als die akzeptierte Antwort, wenn Sie trotz der angestrebten Dezimalstelle richtig aufrunden möchten. Beispiel: 1.054 -> 1.05 1.055 -> 1.06 JEDOCH hier ist ein Randfall: 1.005 -> 1 1.006 -> 1.01 UND 1.015 -> 1.01 1.016 -> 1.02 Seien Sie also vorsichtig.
Jay K
21

Normale Rundung funktioniert mit einem kleinen Tweak:

Math.round(price * 10)/10

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

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

Dies macht es jedoch zu einem String =)

Shad
quelle
Math.round (192.11 * 100) / 100 -> 192.11
krtek
1
Der zweite braucht keine Rundung, es ist eher wieprice.toFixed(2)
Michael Krelin - Hacker
@Krtek ooops, danke, dass du das verstanden hast. Ich habe die Frage falsch gelesen. Antwort aktualisiert.
Shad
2
Das OP fragte, wie eine Zahl aufgerundet werden soll, daher sollte hier Math.ceil anstelle von Math.round verwendet werden.
Kloddant
10

Ganz in der Nähe der Antwort von TheEye , aber ich ändere ein wenig, damit es funktioniert:

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

Hoàng Long
quelle
2

Das OP erwartet zwei Dinge:
A. auf die höheren Zehntel aufrunden und
B. auf der Hundertstelstelle eine Null anzeigen (ein typischer Bedarf mit Währung).

Die Erfüllung beider Anforderungen scheint für jede der oben genannten Methoden eine eigene Methode zu erfordern. 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 liefert ein sehr unterschiedliches Ergebnis mit negativen und exponentiellen Zahlen.

Zum Vergleich zwischen dieser und zwei sehr ähnlichen Antworten siehe die folgenden beiden Ansätze. Der erste rundet einfach auf das nächste Hundertstel pro Normal und der zweite einfach auf das nächste Hundertstel (größer).

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
Kay V.
quelle
2

ok, dies wurde beantwortet, aber ich dachte, Sie möchten vielleicht meine Antwort sehen, die die Funktion math.pow () einmal aufruft. 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 alles zusammen. Ersetzen Sie Math.round () durch Math.ceil (), um abzurunden, anstatt abzurunden, was das OP wollte.

John Grabauskas
quelle
1

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));
}
Behnam Mohammadi
quelle
Als kürzere Alternative: return ('' + num) .split ('.'). Shift ()
Roberto
danke Roberto diese Code-Arbeit, aber entfernen Sie alle Dezimalstellen
Behnam Mohammadi
0

Ich habe die Antwort von @AndrewMarshall schon lange verwendet, aber einige Randfälle gefunden. Die folgenden Tests bestehen nicht:

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

Folgendes verwende ich jetzt, damit sich das Aufrunden richtig verhält:

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

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

Nicolas BADIA
quelle
1
Ihre Testfälle scheinen falsch zu sein. roundUp(37.760000000000005, 4)sollte sein 37.7601und roundUp(5.83333333, 4)sollte sein 5.8334. Diese beiden (und Ihre ersten) gelten alle für das von mir bereitgestellte FN.
Andrew Marshall
@ AndrewMarshall haben Grund, Ihre erwarteten Werte sind für Fall 2 und 3 falsch.
Amn
-3

parseInt rundet immer soo ab .....

console.log(parseInt(5.8)+1);

parseInt () + 1

Omar
quelle