Eine Division wirkt trivial, bis der Teiler plötzlich Null ist. Seit PHP 8.0 gibt es gleich drei Wege, in PHP zu teilen, und je nach Situation ist ein anderer die richtige Wahl. Dieses Tutorial ordnet den Operator, intdiv() und fdiv() ein und zeigt, welche Variante bei einem möglichen Teiler von Null ruhig weiterrechnet.
Drei Wege, in PHP zu dividieren
Wer in PHP teilt, hat seit PHP 8.0 drei Optionen: den klassischen /-Operator, die Integer-Variante intdiv() und die Float-Variante fdiv(). Letztere ist die sicherste Wahl, sobald eine Division durch Null möglich ist, denn PHP fdiv wirft keine Exception. Stattdessen liefert die Funktion die IEEE-754-Sonderwerte INF, -INF oder NAN. Das macht sie ideal für Pipelines, Aggregationen und Statistik-Skripte, in denen ein einzelner /0-Fall den ganzen Lauf nicht abbrechen darf.
Bevor Syntax und Verhalten bei /0 im Detail folgen, hilft eine kurze zeitliche Einordnung der drei Divisionswege.
Zur Einordnung: intdiv() gibt es seit PHP 7.0 und erzwingt ganze Zahlen, fdiv() ist mit PHP 8.0 dazugekommen und arbeitet ausschließlich auf Float-Werten. Der /-Operator existiert seit jeher, hat sein Verhalten bei /0 aber mit PHP 8.0 von Warning + INF auf eine harte DivisionByZeroError-Exception umgestellt. Dieses Tutorial zeigt das Verhalten aller drei Varianten und gibt klare Empfehlungen, wann welche die richtige Wahl ist.
Syntax und Rückgabewert von fdiv()
fdiv() erwartet zwei Float-Werte und gibt einen Float zurück. Integer werden automatisch in Float konvertiert. Ein einfaches Beispiel zeigt das Standardverhalten.
<?php
fdiv(float $num1, float $num2): float
Im Normalfall verhält sich fdiv() wie der /-Operator. Erst bei /0 zeigt sich der Unterschied: Statt einer Exception kommt ein IEEE-754-Sonderwert. Diese Werte sind keine Fehler, sondern definierte Float-Zustände.
<?php
echo 10 / 3; /* 3.3333333333333 */
echo intdiv(10, 3); /* 3 */
echo fdiv(10, 3); /* 3.3333333333333 */
Solange kein /0 im Spiel ist, sind / und fdiv() funktional äquivalent. Die Funktion lohnt sich genau dann, wenn der Divisor aus einer Datenquelle kommt, in der eine Null nicht auszuschließen ist, etwa aus einer Datenbank-Spalte oder einem Aggregations-Schritt.
Verhalten bei Division durch Null
Hier zeigt sich der eigentliche Wert von PHP fdiv. Der /-Operator und intdiv() werfen seit PHP 8.0 eine Exception. PHP fdiv liefert dagegen INF, -INF oder NAN, je nach Vorzeichen.
<?php
/* Operator: wirft Exception */
try {
echo 1 / 0;
} catch (DivisionByZeroError $e) {
echo 'Operator-Exception: ' . $e->getMessage();
}
/* intdiv: wirft Exception */
try {
echo intdiv(1, 0);
} catch (DivisionByZeroError $e) {
echo 'intdiv-Exception';
}
/* fdiv: kein Crash */
echo fdiv(1, 0); /* INF */
echo fdiv(-1, 0); /* -INF */
echo fdiv(0, 0); /* NAN */
Die drei fdiv-Fälle sind mathematisch sauber definiert. Eine positive Zahl geteilt durch Null tendiert gegen plus unendlich, eine negative gegen minus unendlich, und Null geteilt durch Null ist mathematisch nicht definiert (NAN, "not a number"). Das ist genau der IEEE-754-Standard, an den sich moderne Float-Implementierungen halten.
intdiv() für ganzzahlige Division neben PHP fdiv
PHP fdiv kümmert sich um Floats, für Integer ist intdiv die saubere Wahl. intdiv() ist das Gegenstück zu fdiv(), wenn es um ganzzahlige Ergebnisse geht. Die Funktion teilt zwei Integer und schneidet Nachkommastellen ab. Bei /0 wirft sie eine Exception, bei intdiv(PHP_INT_MIN, -1) zusätzlich einen ArithmeticError wegen Integer-Overflow.
<?php
echo intdiv(7, 2); /* 3 */
echo intdiv(-7, 2); /* -3 (Richtung Null abgeschnitten) */
echo intdiv(100, 7); /* 14 */
try {
intdiv(10, 0);
} catch (DivisionByZeroError $e) {
echo 'Division durch Null';
}
Wer intdiv() defensiv einsetzen will, baut einen kleinen Wrapper, der vorab auf 0 prüft und im Fehlerfall null zurückgibt. Das spart in einer Schleife das try/catch pro Iteration und macht den Code lesbarer.
<?php
function sicherIntDiv(int $a, int $b): ?int
{
if ($b === 0) {
return null;
}
return intdiv($a, $b);
}
var_dump(sicherIntDiv(10, 3)); /* int(3) */
var_dump(sicherIntDiv(10, 0)); /* NULL */
Bei der Frage Cast vs intdiv lohnt sich ein Blick: (int) ($a / $b) liefert dasselbe Integer-Ergebnis, schluckt aber den DivisionByZeroError nicht und akzeptiert auch Float-Eingaben. intdiv() ist die strenge, typsichere Variante. Wer mehr über Cast-Operatoren in PHP wissen will, findet im intval-Tutorial die Details.
INF und NAN nach PHP fdiv sicher erkennen
PHP fdiv liefert eben nicht nur normale Floats. Sobald fdiv() zum Einsatz kommt, sollten die Sonderwerte zuverlässig erkannt werden. PHP bietet dafür drei Funktionen.
<?php
$a = fdiv(1, 0);
$b = fdiv(0, 0);
$c = fdiv(10, 3);
var_dump(is_finite($a)); /* false (INF) */
var_dump(is_finite($b)); /* false (NAN) */
var_dump(is_finite($c)); /* true */
var_dump(is_infinite($a)); /* true */
var_dump(is_nan($b)); /* true */
Im Alltag ist is_finite() die einfachste Prüfung. Sie liefert true genau dann, wenn der Wert weder INF noch NAN ist, also ein normaler Float. Wer beide Sonderfälle gleich behandeln will (etwa "rechne ich mit dem Wert weiter oder nicht?"), spart sich damit zwei separate Aufrufe.
Eine wichtige Eigenheit von NAN: Der mathematische Vergleich NAN == NAN ist false, weil NAN nichts gleicht, nicht einmal sich selbst. NAN === NAN ist als Strikt-Vergleich von PHP true. Wer auf NAN testet, sollte deshalb is_nan() nutzen, nicht ===.
flowchart TD
A[Division noetig] --> B{Welche Variante?}
B -->|Operator /| C{Divisor = 0?}
B -->|intdiv| C
B -->|fdiv| D[Ergebnis: float, INF oder NAN]
C -->|Ja| E[DivisionByZeroError]
C -->|Nein| F[Float bzw int]
D --> G[is_finite pruefen]
G --> H[Wert verarbeiten]
PHP fdiv in einer Aggregations-Schleife
Der prototypische Anwendungsfall für PHP fdiv ist eine Schleife, die über Datensätze läuft und pro Zeile eine Quote berechnet. Wenn ein Datensatz keinen Divisor hat, soll die Schleife nicht abbrechen, sondern eine sinnvolle Meldung produzieren.
<?php
$daten = [
['name' => 'Lina', 'umsatz' => 1000, 'auftraege' => 20],
['name' => 'Tobias', 'umsatz' => 500, 'auftraege' => 0],
['name' => 'Mia', 'umsatz' => 1500, 'auftraege' => 30],
];
foreach ($daten as $zeile) {
$schnitt = fdiv($zeile['umsatz'], $zeile['auftraege']);
if (is_finite($schnitt)) {
printf("%s: %.2f Euro pro Auftrag\n", $zeile['name'], $schnitt);
} else {
printf("%s: keine Auftraege im Zeitraum\n", $zeile['name']);
}
}
Mit fdiv() plus is_finite() ist der Code linear lesbar, ohne dass try/catch jeden Iterationsschritt einrahmt. Ein zweiter Vorteil: Die Logik für "ungültige Berechnung" steht direkt neben der eigentlichen Berechnung, was beim Debuggen hilft.
Best Practices für sichere Division mit PHP fdiv
PHP fdiv löst die Division-durch-Null-Frage elegant. Drei einfache Regeln helfen bei der Wahl der richtigen Variante. Erstens: Im normalen Geschäftslogik-Code mit klar definierten Eingaben bleibt / die richtige Wahl. Sie ist am kürzesten und das Verhalten ist allen Lesern bekannt. Zweitens: Sobald der Divisor aus einer externen Quelle kommt (User-Input, DB-Spalte, API-Antwort), lohnt sich fdiv(), weil es ohne try/catch weiterarbeitet. Drittens: intdiv() immer dann, wenn das Ergebnis garantiert eine ganze Zahl sein soll und beide Operanden Integer sind. In allen anderen Fällen ist die normale Float-Division einfacher zu lesen.
In Code-Reviews lohnt es sich, PHP fdiv zu kommentieren, weil viele Entwickler die Funktion nicht aktiv im Repertoire haben. Eine kurze Notiz wie /* fdiv weil Auftraege auch 0 sein kann */ macht klar, warum hier ein anderes Werkzeug genutzt wird.
Wer PHP fdiv in eigenen Projekten einsetzt, profitiert von einer klaren Trennung zwischen Aufruf und Logik. Die Funktion bleibt dadurch wartbar und gut lesbar.
Fazit zu PHP fdiv
fdiv() ist die jüngste der drei PHP-Divisionsvarianten und die einzige, die bei /0 keine Exception wirft. PHP fdiv liefert IEEE-754-Werte INF, -INF oder NAN und arbeitet damit auch in Pipelines weiter, in denen ein einzelner /0-Fall sonst den ganzen Lauf abbrechen würde. intdiv() bleibt die richtige Wahl für ganzzahlige Division mit Integer-Operanden. Der /-Operator ist seit PHP 8.0 streng und wirft DivisionByZeroError. Wer is_finite(), is_infinite() und is_nan() zur Prüfung kennt, kann mit allen drei Varianten robusten und gut lesbaren Code schreiben.
