Die Math.round() Funktion gibt die nächstgelegenen Ganzzahl einer Zahl zurück (kaufmännisches Runden).

Das obige Beispiel kann Rundungsfehler aufgrund von Gleitkommaarithmetik haben. Runden von 1,005 sollte ein Erwartetes Resultat von 1,01 haben, ergibt aber 1.

precisionRound(1.050, 1); // Erwartet 1.1,  Ergebnis 1.1 (richtig)
precisionRound(1.005, 2); // Erwartet 1.01, Ergebnis 1   (falsch)

Siehe im Abschnitt Eine Bessere Lösung für einen vorgeschlagene Lösung.

Eine Bessere Lösung

Der precision Parameter funktioniert genauso wie in PHP und Excel, eine positive 1 rundet auf eine Dezimalstelle und -1 rundet auf die Zenerstelle.

function round(number, precision) {
    var shift = function (number, precision, reverseShift) {
        if (reverseShift) {
            precision = -precision;
        }
        var numArray = ("" + number).split("e");
        return  + (numArray[0] + "e" + (numArray[1] ? (+numArray[1] + precision) : precision));
    };
    return shift(Math.round(shift(number, precision, false)), precision, true);
}

Die vorgeschlagene Lösung vermeidet das Problem mit der Gleitkommaarithmetik. Als erstes wird die ganze Zahl abhängig von der Präzision (precision) auf Dezimalstellen verschoben. Danach wird mit Math.round() gerundet. Zum Schluss wird die Verschiebung der ganzen Zahl auf Basis der der Präzision zurückgängig gemacht.

Im folgenden werden die inneren Schritte für ein Besseres Verschändnis aufgezeigt:

round(1.005, 2);
1.005 // Verschiebung um 2 nach links
100.5 // Math.round();
101   // Verschiebung um 2 nach rechts
1.01  // Ergebnis

Testergebnisse

round(1.050, 1); // expected 1.1 , result 1.1  (correct)
round(1.005, 2); // expected 1.01, result 1.01 (correct)

round(3456.3456,  3); // 3456.346
round(3456.3456,  2); // 3456.35
round(3456.3456,  1); // 3456.3
round(3456.3456,  0); // 3456
round(3456.3456, -1); // 3460
round(3456.3456, -2); // 3500
round(3456.3456, -3); // 3000

round(undefined, 1        ); // NaN
round(null     , 1        ); // NaN
round("a"      , 1        ); // NaN
round(1        , null     ); // NaN
round(1        , undefined); // NaN
round(1        , "a"      ); // NaN

Syntax

Math.round(x)

Parameter

x
Eine Zahl.

Rückgabewert

Den Wert der gegebenen Zahl, der zur nächsten ganzen Zahl gerundet wird.

Beschreibung

Wenn der Nachkommateil des Argumentes größer als 0.5 ist, wird das Argument zur nächst größeren ganzen Zahl aufgerundet. Wenn der Nachkommateil kleiner als 0.5 ist, wird auf die nächst kleinere ganze Zahl abgerundet. Wenn der Nachkommateil genau 0.5 ist, wird auf die nächst größere ganze Zahl aufgerundet. Das Verhalten bei 0.5 ist anders als bei vielen anderen Programmiersprachen, welche zur nächsten ganzen Zahl, welche an 0 liegt runden (das kann zu unterschiedlichen Ergebnissen bei negativen Zahlen mit einem exakten Nachkommateil von 0.5 führen).

Weil round() eine statische Methode von Math ist, benutzt man als Aufruf immer Math.round() und nicht in dem man zunächst ein Math-Objekt erzeugt um anschliessend die round()-Methode aufzurufen (Math ist kein Konstruktor).

Beispiele

Math.round(20.49);  // 20
Math.round(20.5);   // 21
Math.round(42);     // 42
Math.round(-20.5);  // -20
Math.round(-20.51); // -21

Dezimale Rundung

// 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 (value === null || isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
      return NaN;
    }
    // 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 -- round works towards +∞ when in -between two values
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1);      // -50 -- round works towards +∞ when in -between two values
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.0 -- round works towards +∞ when in -between two values
// Floor
Math.floor10(55.59, -1);   // 55.5
Math.floor10(59, 1);       // 50
Math.floor10(-55.51, -1);  // -55.6 -- floor is always lower than or equals to floored number: -55.6 < -55.51
Math.floor10(-51, 1);      // -60 -- ditto
// Ceil
Math.ceil10(55.51, -1);    // 55.6
Math.ceil10(51, 1);        // 60
Math.ceil10(-55.59, -1);   // -55.5 -- ceil is always equals or above veiled number: -55.5 > -55.59
Math.ceil10(-59, 1);       // -59 -- ditto

PHP ähnliche Rundungsmethode

Der Quelltext unten zeigt, wie man eine eigene Version von Math.round unter einem eigenen Namensraum mit einem Parameter für die Nachkommastellen erstellt. Leider unterstützt diese Methode keinen Konvertierung zu und von Strings, wie das oben stehende Beispiel zur dezimalen Rundung. Dabei arbeitet diese Methode ähnlich wie bei PHP und Excel, wo bei dem Wert 1 für die Nachkommastellen auf eine Nachkommastelle Rundet und der Wert -1 auf die Zehnerstellen rundet.

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

 

Das obige Beispiel kann Rundungsfehler aufgrund von Gleitkommaarithmetik haben. Runden von 1,005 sollte ein Erwartetes Resultat von 1,01 haben, ergibt aber 1.

precisionRound(1.050, 1); // Erwartet 1.1,  Ergebnis 1.1 (richtig)
precisionRound(1.005, 2); // Erwartet 1.01, Ergebnis 1   (falsch)

Siehe im Abschnitt Eine Bessere Lösung für einen vorgeschlagene Lösung.

 

Spezifikationen

Spezifikation Status Kommentar
ECMAScript 1st Edition. Standard Initiale Definition. Integriert in JavaScript 1.0.
ECMAScript 5.1 (ECMA-262)
Die Definition von 'Math.round' in dieser Spezifikation.
Standard  
ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Math.round' in dieser Spezifikation.
Standard

 

ECMAScript Latest Draft (ECMA-262)
Die Definition von 'Math.round' in dieser Spezifikation.
Entwurf  

Browserkompatibilität

FeatureChromeEdgeFirefoxInternet ExplorerOperaSafari
Grundlegende Unterstützung Ja Ja1 Ja Ja Ja
FeatureAndroid webviewChrome for AndroidEdge mobileFirefox for AndroidOpera AndroidiOS SafariSamsung Internet
Grundlegende Unterstützung Ja Ja Ja4 Ja Ja Ja

Siehe auch

Schlagwörter des Dokuments und Mitwirkende

 Mitwirkende an dieser Seite: schlagi123, RefToDev, Krayzeee92, DanMyshkin, michaelkoehne
 Zuletzt aktualisiert von: schlagi123,