Ob beim Bezahlen im Onlineshop, beim Berechnen von Statistiken oder beim Speichern von Messergebnissen: Korrekt gerundete Zahlen sind in der Softwareentwicklung unverzichtbar. Die PHP-Funktion round() ist das zentrale Werkzeug für mathematisches Runden und bietet vier verschiedene Rundungsmodi für jeden Anwendungsfall.
In diesem Tutorial lernst du die Syntax, alle vier Rundungsmodi, typische Praxisbeispiele und die Fallstricke der Gleitkomma-Arithmetik kennen. Am Ende weißt du, wann du round() einsetzt und wann ceil(), floor() oder number_format() die bessere Wahl ist.
Syntax und Parameter von round()
Die Funktion erwartet eine Zahl als Pflichtparameter und bietet zwei optionale Parameter für Präzision und Rundungsmodus:
float round(float $num, int $precision = 0, int $mode = PHP_ROUND_HALF_UP)
Der Parameter $num ist die zu rundende Zahl. Mit $precision legst du fest, auf wie viele Nachkommastellen gerundet wird. Positive Werte stehen für Dezimalstellen, negative Werte runden vor dem Komma (z.B. auf Zehner oder Hunderter). Der dritte Parameter $mode bestimmt, wie mit dem Grenzfall .5 umgegangen wird.
<?php
echo round(3.14159, 2); // 3.14
echo round(1234.56, -2); // 1200
?>
Die Funktion gibt immer einen float zurück, auch wenn das Ergebnis eine Ganzzahl ist. round(3.0) ergibt float(3), nicht int(3).
Die vier Rundungsmodi im Überblick
PHP bietet vier Konstanten, die das Verhalten bei .5-Werten steuern. Werte, die nicht exakt auf .5 enden, werden immer zum nächsten Nachbarn gerundet, unabhängig vom Modus.
PHP_ROUND_HALF_UP (Standard)
Werte mit .5 werden vom Nullpunkt weg gerundet. Das ist die klassische Schulbuch-Rundung:
<?php
echo round(1.5); // 2
echo round(2.5); // 3
echo round(-1.5); // -2
?>
PHP_ROUND_HALF_DOWN
Werte mit .5 werden zum Nullpunkt hin gerundet:
<?php
echo round(1.5, 0, PHP_ROUND_HALF_DOWN); // 1
echo round(2.5, 0, PHP_ROUND_HALF_DOWN); // 2
echo round(-1.5, 0, PHP_ROUND_HALF_DOWN); // -1
?>
PHP_ROUND_HALF_EVEN (Bankers' Rounding)
Liegt ein Wert genau auf .5, wird zur nächsten geraden Zahl gerundet. Dieser Modus wird in Statistiken und Finanzen verwendet, um bei vielen Rundungen eine systematische Verzerrung zu vermeiden:
<?php
echo round(1.5, 0, PHP_ROUND_HALF_EVEN); // 2 (gerade)
echo round(2.5, 0, PHP_ROUND_HALF_EVEN); // 2 (gerade)
echo round(3.5, 0, PHP_ROUND_HALF_EVEN); // 4 (gerade)
?>
PHP_ROUND_HALF_ODD
Wie HALF_EVEN, aber es wird zur nächsten ungeraden Zahl gerundet. Dieser Modus ist selten im Einsatz:
<?php
echo round(1.5, 0, PHP_ROUND_HALF_ODD); // 1 (ungerade)
echo round(2.5, 0, PHP_ROUND_HALF_ODD); // 3 (ungerade)
?>
Alle Rundungsmodi im direkten Vergleich
Die folgende Tabelle zeigt, wie sich dieselbe Zahlenreihe je nach Modus unterschiedlich runden lässt:
| Zahl | HALF_UP | HALF_DOWN | HALF_EVEN | HALF_ODD |
| 0.5 | 1 | 0 | 0 | 1 |
| 1.5 | 2 | 1 | 2 | 1 |
| 2.5 | 3 | 2 | 2 | 3 |
| 3.5 | 4 | 3 | 4 | 3 |
| -1.5 | -2 | -1 | -2 | -1 |
| -2.5 | -3 | -2 | -2 | -3 |
So siehst du auf einen Blick, wann welcher Modus welches Ergebnis liefert.
Bankers' Rounding: Wann es Pflicht ist
In der Finanzbuchhaltung kann Bankers' Rounding (HALF_EVEN) vorgeschrieben sein, zum Beispiel nach IEEE 754 oder in bestimmten EU-Regulierungen. Der Grund: Bei vielen Rundungen gleichen sich Auf- und Abrundungen statistisch aus, während HALF_UP systematisch nach oben verzerrt.
<?php
/* 1000 Transaktionen: HALF_UP vs. HALF_EVEN */
$werte = [];
for ($i = 0; $i < 1000; $i++) {
$werte[] = $i * 0.5 + 0.25;
}
$summeUp = 0;
$summeEven = 0;
foreach ($werte as $w) {
$summeUp += round($w, 0, PHP_ROUND_HALF_UP);
$summeEven += round($w, 0, PHP_ROUND_HALF_EVEN);
}
echo "HALF_UP: $summeUp\n";
echo "HALF_EVEN: $summeEven\n";
/* Die Summendifferenz zeigt die Verzerrung */
?>
Praxisbeispiele
Die folgenden Beispiele zeigen round() in typischen Alltagssituationen.
Preise runden (2 Dezimalstellen)
<?php
$netto = 49.95;
$brutto = round($netto * 1.19, 2);
echo $brutto; // 59.44
?>
Auf Zehner und Hunderter runden (negative Präzision)
<?php
echo round(1234.56, -1); // 1230
echo round(1234.56, -2); // 1200
echo round(1234.56, -3); // 1000
?>
Negative Zahlen runden
Bei negativen Zahlen bedeutet „vom Nullpunkt weg“ (HALF_UP), dass -2.5 zu -3 gerundet wird, also in Richtung der größeren Absolutzahl:
<?php
echo round(-2.5); // -3 (vom Nullpunkt weg)
echo round(-2.5, 0, PHP_ROUND_HALF_DOWN); // -2
echo round(-2.5, 0, PHP_ROUND_HALF_EVEN); // -2
?>
Rundung in Arrays mit array_map
In der Praxis werden selten einzelne Zahlen gerundet, sondern ganze Datenreihen. Mit array_map() rundest du alle Werte eines Arrays in einem Schritt:
<?php
$messwerte = [3.456, 7.891, 2.345, 9.678];
/* Einfach: Auf Ganzzahlen runden */
$gerundet = array_map('round', $messwerte);
// [3, 8, 2, 10]
/* Mit Closure: Auf 1 Dezimalstelle */
$gerundet = array_map(
fn($w) => round($w, 1),
$messwerte
);
// [3.5, 7.9, 2.3, 9.7]
?>
Rundung auf beliebige Schritte (5er, Viertelstunden)
Manchmal musst du nicht auf Dezimalstellen runden, sondern auf bestimmte Schrittweiten. Das allgemeine Pattern lautet: round($wert / $schritt) * $schritt.
<?php
/* Auf 5 Cent runden */
$preis = 12.43;
echo round($preis * 20) / 20; // 12.45
/* Auf Viertelstunden runden (15 Minuten) */
$minuten = 37;
echo round($minuten / 15) * 15; // 45
/* Auf 25er-Stufen runden */
$wert = 137;
echo round($wert / 25) * 25; // 150
?>
Vergleich: round(), ceil(), floor() und number_format()
Jede dieser Funktionen hat einen eigenen Zweck. Die folgende Tabelle zeigt die Unterschiede auf einen Blick:
| Funktion | Zweck | Rückgabetyp | Dezimalstellen | Modus wählbar |
| round() | Mathematisch runden | float | Ja | Ja |
| ceil() | Immer aufrunden | float | Nein | Nein |
| floor() | Immer abrunden | float | Nein | Nein |
| number_format() | Formatieren für Anzeige | string | Ja | Nein |
| sprintf() | Formatieren für Anzeige | string | Ja | Nein |
Faustregeln: Verwende round(), wenn du mit dem Ergebnis weiterrechnen willst. Greife zu number_format() oder sprintf(), wenn du das Ergebnis nur anzeigen möchtest. Brauchst du garantiertes Auf- oder Abrunden, nimm ceil() oder floor().
Fallstricke und Best Practices
Beim Runden in PHP gibt es einige Stolperfallen, die besonders bei Finanzberechnungen zu Problemen führen können.
Gleitkomma-Präzision (Float-Problem)
Computer speichern Fließkommazahlen intern als Binärbrüche. Viele Dezimalwerte lassen sich nicht exakt darstellen. Das führt zu überraschenden Ergebnissen:
<?php
$summe = 0.1 + 0.2;
echo $summe; // 0.30000000000000004
echo round($summe, 2); // 0.3 (hier korrekt)
?>
Der Klassiker: round(2.55, 1) ergibt 2.5 statt 2.6
Dieses Problem trifft Entwickler bei Preisberechnungen besonders hart:
<?php
echo round(2.55, 1); // 2.5 (nicht 2.6!)
/* Warum? 2.55 wird intern als
2.54999999... gespeichert */
echo sprintf('%.20f', 2.55);
// 2.54999999999999982236
?>
Lösungen für exakte Finanzberechnungen:
<?php
/* Lösung 1: Rechne in Cent (Integer) */
$preisInCent = 255; // 2,55 €
echo round($preisInCent / 10) / 10; // 2.6
/* Lösung 2: BCMath für exakte Dezimalrechnung */
echo bcadd('2.55', '0', 1); // 2.5
?>
JSON-Serialisierung und round()
Beim Arbeiten mit REST-APIs ist ein Detail wichtig: json_encode(round(1.0)) erzeugt 1.0 (Float), nicht 1 (Integer). Wenn deine API einen Integer erwartet, caste das Ergebnis explizit:
<?php
$wert = round(5.0);
echo json_encode($wert); // 5.0
echo json_encode((int)$wert); // 5
/* JSON_PRESERVE_ZERO_FRACTION kontrolliert
ob 1.0 als 1.0 oder 1 serialisiert wird */
echo json_encode(1.0, JSON_PRESERVE_ZERO_FRACTION);
// 1.0
?>
Häufig gestellte Fragen
Hier findest du Antworten auf die gängigsten Fragen rund um das Runden in PHP.
Warum ergibt round(2.55, 1) nicht 2.6?
Weil 2.55 intern als 2.54999... gespeichert wird (Float-Darstellungsproblem). Für exakte Ergebnisse rechne in Cent (Integer) oder verwende BCMath.
Wie runde ich auf 5 Cent oder 5 Rappen?
<?php
$betrag = 12.43;
$gerundet = round($betrag * 20) / 20;
echo $gerundet; // 12.45
?>
round() oder number_format() für Preise?
Verwende round() zum Rechnen und number_format() zur Anzeige. round() gibt einen Float zurück, mit dem du weiterrechnen kannst. number_format() gibt einen formatierten String zurück (z.B. „1.234,56“), der nur für die Ausgabe taugt.
Wie runde ich immer auf oder immer ab?
Verwende ceil() zum Aufrunden und floor() zum Abrunden. Diese Funktionen ignorieren die .5-Grenze und runden konsequent in eine Richtung.
Ändert sich round() zwischen PHP-Versionen?
In PHP 8.0 wurde das Typ-Handling verschärft: Nicht-numerische Werte lösen jetzt einen TypeError aus, während PHP 7 sie stillschweigend in 0 umwandelte. Das Rundungsverhalten selbst ist gleich geblieben. Details findest du in der offiziellen PHP-Migrationsanleitung.
Fazit
Die PHP-Funktion round() ist flexibel und deckt mit ihren vier Rundungsmodi die meisten Anforderungen ab. Wähle den Modus passend zur Aufgabe: HALF_UP für Standardrundung, HALF_EVEN für Statistiken und Finanzbuchhaltung. Sei dir der Float-Eigenheiten bewusst, besonders bei Preisberechnungen. Im Zweifel ist die Integer-Cent-Rechnung der sicherste Weg. Für die formatierte Ausgabe greifst du am Ende zu number_format().
