PHP runden: round(), floor() und ceil() und Mathe

round($x) rundet auf die nächste ganze Zahl, floor($x) rundet immer ab und ceil($x) rundet immer auf. Gib round() ein zweites Argument für Nachkommastellen: round(3.14159, 2) ist 3.14.

<?php
$price = 19.456;

echo round($price), "\n";     // nearest whole number
echo round($price, 2), "\n";  // 2 decimal places
echo floor($price), "\n";     // always down
echo ceil($price), "\n";      // always up

Alle drei liefern einen Float, auch wenn der Wert ganzzahlig ist. var_dump(round(5)) gibt float(5) aus, also castest du mit (int), wenn du eine Ganzzahl brauchst.

Auf 2 Nachkommastellen runden

Das zweite Argument von round() ist die Genauigkeit. Eine positive Zahl rundet auf so viele Nachkommastellen. Eine negative Zahl rundet links vom Dezimalpunkt, praktisch für grobe Angaben wie „etwa 1.200 Besucher“.

<?php
$n = 1234.5678;

echo round($n, 2), "\n";   // 2 decimals
echo round($n, 1), "\n";   // 1 decimal
echo round($n, -1), "\n";  // nearest ten
echo round($n, -2), "\n";  // nearest hundred

echo round(2.5), " ", round(-2.5), "\n";  // halves go away from zero
echo round(3.10, 2), "\n";                // trailing zero is not kept

round(3.10, 2) gibt 3.1 aus, weil ein Float nicht weiß, wie viele Nullen du wolltest. Wenn die Zahl auf eine Seite kommt (Preise, Prozente), formatierst du sie stattdessen: number_format() macht mit number_format(3.1, 2) aus 3.1 den String "3.10", und sprintf('%.2f', $x) macht dasselbe.

Halb auf, halb ab oder halb zur geraden Zahl runden

Standardmäßig rundet round() eine Hälfte von null weg, also das kaufmännische Runden, das die meisten in der Schule gelernt haben. Das dritte Argument wählt eine andere Regel für Werte, die genau in der Mitte zwischen zwei Zahlen liegen.

<?php
$values = [1.5, 2.5, -2.5];

foreach ($values as $v) {
    echo $v, ": ",
        round($v, 0, PHP_ROUND_HALF_UP), " up, ",
        round($v, 0, PHP_ROUND_HALF_DOWN), " down, ",
        round($v, 0, PHP_ROUND_HALF_EVEN), " even, ",
        round($v, 0, PHP_ROUND_HALF_ODD), " odd\n";
}

PHP_ROUND_HALF_EVEN ist das „Banker's Rounding“: Hälften gehen zur nächsten geraden Zahl, sodass das Runden vieler Werte mit der Zeit nicht nach oben driftet. Buchhaltungscode will oft genau das.

floor und ceil mit negativen Zahlen

floor() bewegt sich in Richtung minus unendlich und ceil() in Richtung plus unendlich. Bei negativen Zahlen überrascht das: floor(-3.5) ist -4, nicht -3. Wenn du die Nachkommastellen in Richtung null abschneiden willst, castest du stattdessen nach int.

<?php
foreach ([3.7, -3.7] as $x) {
    echo "x = $x\n";
    echo "  floor: ", floor($x), "\n";
    echo "  ceil:  ", ceil($x), "\n";
    echo "  (int): ", (int) $x, "\n";
}

// Pages needed for 23 items at 10 per page
echo ceil(23 / 10), " pages\n";

Die Zeile zur Seitennummerierung ist der klassische Einsatz von ceil(): Auch ein übrig gebliebener Eintrag braucht eine Seite.

Ganzzahlige Division und Modulo

/ liefert einen Float, wenn die Division nicht aufgeht, also ist 7 / 2 gleich 3.5. Für ganzzahlige Division verwendest du intdiv(), das den Rest verwirft, und % für den Rest selbst.

<?php
$minutes = 135;

$hours = intdiv($minutes, 60);
$rest = $minutes % 60;
echo "$minutes minutes = {$hours}h {$rest}m\n";

echo 7 / 2, "\n";
echo intdiv(-7, 2), "\n";   // truncates toward zero
echo -7 % 3, "\n";          // sign of the left operand
echo fmod(7.5, 2), "\n";    // remainder for floats

// Even or odd
foreach ([4, 7] as $n) {
    echo $n, $n % 2 === 0 ? " is even\n" : " is odd\n";
}

% wandelt beide Operanden zuerst in Ganzzahlen um, also ist 7.5 % 2 gleich 1, und seit PHP 8.1 gibt es außerdem Deprecated: Implicit conversion from float 7.5 to int loses precision aus. Verwende fmod(), wenn die Nachkommastellen zählen. Eine Division durch null mit /, intdiv() oder % wirft in PHP 8 einen DivisionByZeroError, also prüfe den Divisor vorher, wenn er aus einer Eingabe kommt.

Potenzen, Wurzeln, abs, max und min

** potenziert (pow() macht dasselbe), sqrt() zieht die Quadratwurzel und abs() entfernt das Vorzeichen. max() und min() nehmen entweder mehrere Argumente oder ein Array.

<?php
echo 2 ** 10, "\n";       // 1024
echo 2 ** -1, "\n";       // 0.5
echo sqrt(144), "\n";     // 12
echo 27 ** (1 / 3), "\n"; // cube root
echo abs(-42), "\n";      // 42

$scores = [72, 95, 88, 61];
echo max($scores), " ", min($scores), "\n";
echo max(3, 9, 4), "\n";
echo array_sum($scores) / count($scores), "\n"; // average

// Clamp a value into the range 0 to 100
$volume = 140;
echo max(0, min(100, $volume)), "\n";

** wird von rechts nach links ausgewertet, also bedeutet 2 ** 3 ** 2 dasselbe wie 2 ** 9. Das Paar max(0, min(100, $x)) ist der übliche Weg, einen Wert zwischen eine untere und eine obere Grenze zu klemmen. M_PI enthält Pi, falls du es für Kreise brauchst.

Zufallszahlen mit random_int und rand

random_int($min, $max) liefert eine zufällige Ganzzahl, beide Enden eingeschlossen. Die Ausgabe ändert sich bei jedem Durchlauf, also klicke ein paarmal auf Run.

<?php
echo "Dice: ", random_int(1, 6), "\n";

// A 6-digit code, zero padded
printf("Code: %06d\n", random_int(0, 999999));

// Random element of an array
$colors = ['red', 'green', 'blue'];
echo "Color: ", $colors[array_rand($colors)], "\n";

// Random float between 0 and 1
echo "Float: ", random_int(0, PHP_INT_MAX) / PHP_INT_MAX, "\n";

Verwende random_int() für alles, was mit Sicherheit zu tun hat: Login-Codes, Tokens, Links zum Zurücksetzen von Passwörtern. rand() und mt_rand() funktionieren weiterhin und nehmen dieselben Argumente ($min, $max), aber ihre Folge lässt sich vorhersagen. Zum Mischen und Auswählen mit einer sicheren Quelle kam mit PHP 8.2 Random\Randomizer ($r->getInt(1, 6), $r->shuffleArray($a)).

Warum floor() manchmal das falsche Ergebnis liefert

Floats werden binär gespeichert, und viele Dezimalwerte (wie 0.1) lassen sich nicht exakt speichern. Meistens versteckt die Ausgabe das, aber floor() und (int) runden nicht, sie schneiden ab, und ein Wert wie 7.999999999 wird zu 7.

<?php
$x = (0.1 + 0.7) * 10;

echo $x, "\n";            // looks like 8
var_dump($x);             // the real value
echo floor($x), "\n";     // 7, not 8
echo floor(round($x, 10)), "\n"; // round first, then floor

Wenn du exakte Dezimalzahlen brauchst, etwa bei Geld, speicherst du ganze Einheiten (Cent als Ganzzahlen: 1999 statt 19.99) und teilst nur für die Anzeige. Vor floor() oder ceil() auf eine sinnvolle Genauigkeit zu runden, wie in der letzten Zeile, behebt ebenfalls die meisten Fälle.