Wie runde ich eine Zahl in Javascript auf?

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).

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

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

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 =)

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

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

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.

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

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

parseInt rundet immer soo ab .....

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

parseInt () + 1