Start · Sprachen · JavaScript · Referenz · Math.round()

Math.round()

Methode

Die statische Methode <code>Math.round()</code> rundet eine Zahl auf die nächstgelegene ganze Zahl. Bei exakt 0,5 wird in Richtung +∞ gerundet.

seit JavaScript ES1 – Baseline: alle Browser und Node.js Kategorie: method-property

Signatur

Math.round(x)

Beschreibung

Math.round() rundet eine Zahl auf die nächstgelegene ganze Zahl. Ist der Nachkommateil größer als 0,5, wird auf die ganze Zahl mit dem nächsthöheren Betrag gerundet. Ist er kleiner als 0,5, wird auf die ganze Zahl mit dem niedrigeren Betrag gerundet. Bei exakt 0,5 wird immer in Richtung +∞ gerundet. Deshalb ergibt Math.round(2.5) den Wert 3, Math.round(-2.5) dagegen -2. Das ist kein kaufmännisches Runden, bei dem man vom Betrag her aufrundet.

Typische Einsatzfälle sind Pixelwerte für Layouts, die Anzeige von Prozentangaben, Durchschnittswerte oder Punktestände. Soll auf eine bestimmte Anzahl Nachkommastellen gerundet werden, multipliziert man vorher mit einer Zehnerpotenz und teilt danach wieder durch sie. Für die reine Anzeige eignen sich meist Number.prototype.toFixed() oder Intl.NumberFormat besser.

Math.round(x) entspricht weitgehend Math.floor(x + 0.5), aber nicht ganz: Für -0 und für Werte mit -0.5 ≤ x < 0 liefert Math.round() das Ergebnis -0, Math.floor(x + 0.5) dagegen 0. Das Argument wird vorher in eine Zahl umgewandelt. null ergibt deshalb 0, nicht numerische Zeichenketten und undefined ergeben NaN.

Weil Math ein statisches Namensraum-Objekt ohne Konstruktor ist, ruft man die Methode immer als Math.round() auf.

Parameter

Name Typ Default Beschreibung
$x Pflicht number Die zu rundende Zahl. Andere Werte werden vorher per Number()-Konvertierung in eine Zahl umgewandelt.

Rückgabewert

Typ
number
Beschreibung
Der auf die nächste ganze Zahl gerundete Wert von x. NaN, Infinity, -Infinity und ±0 werden unverändert zurückgegeben. Für -0.5 ≤ x < 0 ist das Ergebnis -0.

Beispiele

Grundverhalten und Grenzfälle bei 0,5

console.log(Math.round(20.49));  // 20
console.log(Math.round(20.5));   // 21
console.log(Math.round(-20.5));  // -20 (Richtung +∞!)
console.log(Math.round(-20.51)); // -21
console.log(Object.is(Math.round(-0.4), -0)); // true
console.log(Math.round('7.6'));  // 8 (Zeichenkette wird umgewandelt)
console.log(Math.round(undefined)); // NaN
20 21 -20 -21 true 8 NaN

Auf n Nachkommastellen runden (mit Korrektur für Gleitkommafehler)

const roundTo = (value, digits = 2) => {
  const factor = 10 ** digits;
  // Number.EPSILON gleicht Darstellungsfehler wie 1.005 * 100 = 100.49999… aus
  return Math.round((value + Number.EPSILON) * factor) / factor;
};

console.log(Math.round(1.005 * 100) / 100); // 1 (unerwartet)
console.log(roundTo(1.005));              // 1.01
console.log(roundTo(3.14159, 3));         // 3.142
1 1.01 3.142

Fortschritt in Prozent anzeigen

const uploaded = 3_456_789;
const total = 9_870_000;

const percent = Math.round((uploaded / total) * 100);
console.log(`Upload: ${percent} %`);
Upload: 35 %

Symmetrisches (kaufmännisches) Runden für negative Zahlen

// Rundet .5 immer vom Nullpunkt weg, auch bei negativen Werten
const roundHalfAwayFromZero = (x) => Math.sign(x) * Math.round(Math.abs(x));

console.log(Math.round(-2.5));             // -2
console.log(roundHalfAwayFromZero(-2.5));  // -3
console.log(roundHalfAwayFromZero(2.5));   // 3
-2 -3 3

// Wichtig · Fallstricke

  • Negative Zahlen bei 0,5: Math.round(-2.5) ergibt -2, nicht -3. Wer kaufmännisch runden will, verwendet Math.sign(x) * Math.round(Math.abs(x)).
  • Kein Banker's Rounding: JavaScript rundet 0,5 nicht zur nächsten geraden Zahl (anders als etwa Pythons round()). Für Finanzberechnungen sollte man in Cent als ganzen Zahlen oder mit BigInt rechnen.
  • Gleitkomma-Ungenauigkeit: Werte wie 1.005 sind binär nicht exakt darstellbar. Deshalb liefert Math.round(1.005 * 100) / 100 den Wert 1.
  • Negative Null: Für -0.5 ≤ x < 0 ist das Ergebnis -0. === erkennt das nicht, Object.is() schon. Bei einer Division kann daraus -Infinity entstehen.
  • Große Zahlen: Ab Number.MAX_SAFE_INTEGER (253 − 1) sind alle Zahlen bereits ganzzahlig. Das Runden hat dann keine Wirkung mehr.
  • Für die Anzeige sind toFixed() und Intl.NumberFormat oft die bessere Wahl, da sie eine formatierte Zeichenkette liefern.