PHP-Zahlen: Ein umfassender Leitfaden

Zahlen stehen im Mittelpunkt fast jedes PHP-Programms — Elemente zählen, Preise berechnen, Größen messen. Dieses Kapitel behandelt die beiden numerischen Typen, die PHP bietet, wie man Zahlen in verschiedenen Schreibweisen notiert, die Arithmetik- und Mathematikfunktionen, die man am häufigsten verwendet, die Gleitkomma-Präzisionsfalle, die jeden Entwickler mindestens einmal überrascht, sowie die sichere Formatierung und Validierung von Zahlen.

Die numerischen Datentypen in PHP verstehen

PHP verfügt über zwei numerische Datentypen:

• int (Integer) — eine ganze Zahl ohne Nachkommastellen, wie 42 oder -7.
• float (Gleitkommazahl, auch double genannt) — eine Zahl mit Nachkommastellen, wie 3.14 oder -0.5.

PHP ist schwach typisiert, daher muss der Typ nie deklariert werden. PHP wählt int oder float automatisch anhand des geschriebenen Literals und der durchgeführten Operationen. Den Typ zur Laufzeit prüft man mit gettype() oder var_dump().

Die Größe eines Integers ist plattformabhängig. Auf einem 64-Bit-System (heute der Normalfall) reicht ein Integer von -9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807; auf einem 32-Bit-System beträgt der Bereich -2.147.483.648 bis 2.147.483.647. Die genaue Grenze ist als Konstante PHP_INT_MAX verfügbar. Überschreitet eine Berechnung diesen Wert, wandelt PHP das Ergebnis stillschweigend in einen float um, anstatt einen Überlauf zu erzeugen — sehr große Integer können dadurch an Präzision verlieren.

Zahlenliterale schreiben

Man ist nicht auf die einfache Dezimalschreibweise beschränkt. PHP versteht mehrere Zahlensysteme sowie Unterstriche zur besseren Lesbarkeit:

<?php
$dec = 42;        // decimal integer
$float = 3.14;    // floating-point
$hex = 0x1A;      // hexadecimal, equals 26
$oct = 0o17;      // octal (PHP 8.1+ "0o" prefix), equals 15
$bin = 0b101;     // binary, equals 5
$big = 1_000_000; // underscores are ignored (PHP 7.4+), equals 1000000

echo $hex, "\n";  // 26
echo $oct, "\n";  // 15
echo $bin, "\n";  // 5
echo $big, "\n";  // 1000000

var_dump($dec);   // int(42)
var_dump($float); // float(3.14)
?>

Die Unterstriche sind rein kosmetischer Natur — PHP ignoriert sie —, aber sie machen lange Zahlen wie 1_000_000 wesentlich lesbarer. Im Kapitel PHP-Datentypen erfahren Sie, wie diese zusammen mit Strings, Booleans und Arrays einzuordnen sind.

Arithmetische Operationen in PHP

PHP unterstützt die standardmäßigen arithmetischen Operatoren: Addition (+), Subtraktion (-), Multiplikation (*), Division (/), Modulus (%) und Potenzierung (**). Der vollständige Satz wird in PHP-Operatoren behandelt. Hier sind alle Grundoperationen im Einsatz:

<?php
$num1 = 10;
$num2 = 5;

// Addition
$result = $num1 + $num2;
echo "\$num1 + \$num2 = ";
echo $result; // 15

// Subtraction
$result = $num1 - $num2;
echo "\n\$num1 - \$num2 = ";
echo $result; // 5

// Multiplication
$result = $num1 * $num2;
echo "\n\$num1 * \$num2 = ";
echo $result; // 50

// Division
$result = $num1 / $num2;
echo "\n\$num1 / \$num2 = ";
echo $result; // 2

// Modulus
$result = $num1 % $num2;
echo "\n\$num1 % \$num2 = ";
echo $result; // 0
?>

Division, Ganzzahldivision und Modulus

Division in PHP hat eine wissenswerte Besonderheit. Der Operator / gibt einen float zurück, wenn das Ergebnis keine ganze Zahl ist, und einen int, wenn die Operanden aufgehen. Für ein immer ganzzahliges Ergebnis verwendet man intdiv(). Für den Rest funktioniert % bei Integern und fmod() bei Floats:

<?php
var_dump(10 / 4);        // float(2.5)  — not evenly divisible
var_dump(10 / 5);        // int(2)      — evenly divisible
var_dump(intdiv(10, 4)); // int(2)      — integer division, remainder dropped
var_dump(10 % 4);        // int(2)      — modulus (remainder)
var_dump(fmod(10.5, 3)); // float(1.5)  — floating-point remainder
?>

Die Division durch null wirft in PHP 8 und später einen DivisionByZeroError, daher sollte der Divisor vor der Division überprüft werden, falls er 0 sein könnte.

Gleitkomma-Präzision

Floats können nicht jeden Dezimalwert exakt darstellen, da sie binär gespeichert werden. Dies führt zu einer klassischen Überraschung:

<?php
var_dump(0.1 + 0.2 === 0.3); // bool(false) — not exactly equal!

// Compare floats with a small tolerance instead:
$epsilon = 1e-9;
var_dump(abs((0.1 + 0.2) - 0.3) < $epsilon); // bool(true)
?>

0.1 + 0.2 ist tatsächlich 0.30000000000000004, daher schlägt der strenge ===-Vergleich fehl, obwohl echo es zur Anzeige auf 0.3 rundet. Die Faustregel lautet: Floats niemals mit == oder === vergleichen — stattdessen prüfen, ob ihre Differenz innerhalb einer kleinen Toleranz liegt (einem Epsilon). Für Geldbeträge und andere dezimalgenaue Berechnungen sollten Werte als Integer-Cent gespeichert oder die BCMath- bzw. GMP-Erweiterungen verwendet werden.

Erweiterte mathematische Funktionen in PHP

Neben den Operatoren liefert PHP einen umfangreichen Satz eingebauter Mathematikfunktionen. Die häufigsten sind:

• abs() — der Absolutbetrag (nicht-negativer Wert) einer Zahl
• ceil() — rundet auf zur nächsten ganzen Zahl
• floor() — rundet ab zur nächsten ganzen Zahl
• round() — rundet auf die nächste ganze Zahl oder auf eine angegebene Anzahl von Dezimalstellen
• sqrt() — die Quadratwurzel einer Zahl
• pow() — potenziert eine Zahl (entspricht dem Operator **)
• max() / min() — der größte / kleinste der übergebenen Werte
• rand() / random_int() — eine Zufallszahl (random_int() ist kryptografisch sicher)

Die vollständige Liste befindet sich in der PHP-Math-Referenz. Hier eine Auswahl im Einsatz:

<?php
$num1 = -10;
$num2 = 2.7;

// Absolute value
$result = abs($num1);
echo "abs(\$num1) = ";
echo $result  . "\n"; // 10

// Round up
$result = ceil($num2);
echo "ceil(\$num2) = ";
echo $result . "\n"; // 3

// Round down
$result = floor($num2);
echo "floor(\$num2) = ";
echo $result . "\n"; // 2

// Square root
$result = sqrt(9);
echo "sqrt(9) = ";
echo $result . "\n";  // 3

// Raise to power
$result = pow(2, 3);
echo "pow(2, 3) = ";
echo $result; // 8
?>

Zahlen für die Ausgabe formatieren

Rohe Zahlen sehen auf einer Seite selten gut aus. number_format() fügt Tausendertrennzeichen hinzu und legt die Anzahl der Dezimalstellen fest; round() steuert die Präzision bei Berechnungen:

<?php
echo number_format(1234567.891, 2), "\n";          // 1,234,567.89
echo number_format(1234567.891, 2, '.', ' '), "\n"; // 1 234 567.89 (custom separators)
echo round(3.14159, 2), "\n";                       // 3.14
?>

Der zweite und die folgenden Parameter von number_format() ermöglichen es, die Anzahl der Dezimalstellen sowie das Dezimal- und Tausendertrennzeichen zu wählen — praktisch für länderspezifische Ausgaben.

Numerische Werte prüfen und konvertieren

Wenn Daten aus Formularen, URLs oder Dateien ankommen, sind es Zeichenketten. Vor arithmetischen Operationen sollten diese validiert werden. is_int() und is_float() prüfen den tatsächlichen Typ, während is_numeric() prüft, ob eine Zeichenkette wie eine Zahl aussieht. Zur Konvertierung verwendet man die Typumwandlung mit (int) / (float) oder floatval():

<?php
var_dump(is_int(42));          // bool(true)
var_dump(is_float(3.14));      // bool(true)
var_dump(is_numeric("123"));   // bool(true)  — numeric string
var_dump(is_numeric("12abc")); // bool(false) — not numeric

echo (int) "42px", "\n";       // 42  — leading digits are kept, the rest dropped
echo PHP_INT_MAX, "\n";        // 9223372036854775807 on a 64-bit system
?>

Verwandte Typprüfungen haben eigene Kapitel: is_int() und is_float().

Fazit

Zusammenfassend lässt sich sagen, dass Zahlen eine entscheidende Rolle in der PHP-Programmierung spielen und es wichtig ist, ein solides Verständnis dafür zu haben, wie man mit ihnen arbeitet. Ob einfache Arithmetik oder erweiterte mathematische Funktionen — PHP bietet eine Vielzahl von Werkzeugen, um die Aufgabe zu erledigen. Mit dem Wissen aus diesem Artikel sind Sie nun gerüstet, jede zahlenbasierte Aufgabe in Ihren PHP-Projekten zu bewältigen.

Übungen