PHP floor() Funktion: Zahlen präzise abrunden mit Beispielen, Vergleichen und Fallstricken

Wer in PHP sicher abrunden will, kommt an floor() nicht vorbei. Die Funktion ist klar, robust und spart viele typische Fehler beim Umgang mit Zahlen.

1. Einleitung: Was ist die PHP floor() Funktion und wozu dient sie?

Die PHP floor() Funktion rundet eine Zahl immer abwärts auf die nächste ganze Zahl ab. Dabei spielt es keine Rolle, ob der Wert positiv oder negativ ist. Sie sorgt also dafür, dass Sie stets die größte ganze Zahl kleiner oder gleich dem Ausgangswert erhalten.

Typische Anwendungsbereiche
Sie nutzen floor(), wenn Sie exakte Ganzzahlen benötigen, etwa bei der Berechnung von Lagerbeständen, Seitenzahlen für die Paginierung oder beim Umrechnen von Werten (z.B. Sekunden zu Minuten).

Wichtiger Unterschied zu anderen Rundungsfunktionen:

• Bei positiven Zahlen entfernt floor() die Nachkommastellen Richtung Null.
• Bei negativen Zahlen geht der Wert noch weiter ins Negative. Das ist ein häufiger Stolperstein!

2. Syntax der floor() Funktion im Detail

Syntax:

float floor(int|float $fZahl) 

Parameter:

• $fZahl: Der numerische Wert, der abgerundet werden soll (kann int oder float sein).

Rückgabewert:

• Immer ein float, selbst wenn das Ergebnis eine ganze Zahl ist. Das erlaubt auch extrem große Werte jenseits der Integer-Grenze.

Beispiel:

/** $fErgebnis ist vom Typ float, selbst wenn $fZahl eine ganze Zahl ist **/ 


$fErgebnis = floor(10); 
/** ergibt 10.0 **/ 

3. Praktische Anwendungsbeispiele der floor() Funktion

Hier die wichtigsten Anwendungsfälle, jeweils mit PHP-Code im einheitlichen Stil.

3.1 Abrunden positiver Gleitkommazahlen

/** Abrunden einer positiven Kommazahl **/ 


$fZahl = 4.7; 


$fAbgerundet = floor($fZahl); 


echo $fAbgerundet; /** Ausgabe: 4 **/ 

$fZahl = 4.01; 


$fAbgerundet = floor($fZahl); 


echo $fAbgerundet; /** Ausgabe: 4 **/ 

3.2 Abrunden negativer Gleitkommazahlen

/** floor() bei negativen Zahlen: Wert entfernt sich weiter von Null **/ 


$fZahl = -4.7; 


$fAbgerundet = floor($fZahl); 


echo $fAbgerundet; /** Ausgabe: -5 **/ 

$fZahl = -4.01; 


$fAbgerundet = floor($fZahl); 


echo $fAbgerundet; /** Ausgabe: -5 **/ 

Achtung:
Bei negativen Zahlen rundet floor() immer zum nächstkleineren Wert, d.h. weg von Null!

3.3 Verhalten bei ganzen Zahlen (Integers)

/** Bei Ganzzahlen bleibt der Wert erhalten, Rückgabetyp ist trotzdem float **/ 


$iZahl = 5; 


$fAbgerundet = floor($iZahl); 


echo $fAbgerundet; /** Ausgabe: 5 **/ 

$iZahl = -5; 


$fAbgerundet = floor($iZahl); 


echo $fAbgerundet; /** Ausgabe: -5 **/ 

4. floor() im direkten Vergleich: Wann welche Rundungsfunktion?

Gerade im direkten Vergleich mit ceil() wird deutlich, wie grundverschieden die Rundungsstrategien arbeiten. Das richtige Verständnis spart viele Stolperfallen bei der Zahlverarbeitung.

4.1 floor() vs. ceil()

Unterschied:

• floor() rundet immer abwärts (zum nächstkleineren Wert).
• ceil() rundet immer aufwärts (zum nächstgrößeren Wert).

4.2 floor() vs. round()

• round() rundet nach kaufmännischer Regel (ab .5 wird aufgerundet).
• Kann auf beliebige Dezimalstellen runden.

4.3 floor() vs. (int) Typecasting und intval()

• (int) und intval() schneiden Nachkommastellen einfach ab, Richtung Null.
• Das führt bei negativen Zahlen zu einem anderen Ergebnis!

Leistung:

• Typecasting zu (int) ist minimal schneller als floor(), da keine Funktionsaufrufe.

Empfehlung:

• Für korrektes Abrunden immer floor() nutzen, speziell bei negativen Zahlen.

5. Häufige Fallstricke und Lösungen mit PHP floor()

Beim Abrunden von Kommazahlen tauchen oft überraschende Ergebnisse auf. Meist steckt dahinter die spezielle Art, wie Computer Gleitkommazahlen intern darstellen.

5.1 Die Tücken der Gleitkommazahl-Genauigkeit

Problem:
PHP (wie alle Programmiersprachen) speichert Kommazahlen als Binärwerte. Das führt zu Rundungsfehlern.

/** Erwartung: 2.3 * 100 = 230, aber... **/ 


$fErgebnis = floor(2.3 * 100); 


echo $fErgebnis; /** Ausgabe: 229 **/ 

Grund:
Der Wert von 2.3 * 100 ist intern oft 229.999999…
Lösung:
Vorher auf gewünschte Dezimalstelle runden!

$fErgebnis = floor(round(2.3 * 100, 4)); 


echo $fErgebnis; /** Ausgabe: 230 **/ 

Oder von Anfang an mit Ganzzahlen arbeiten (z.B. Cent statt Euro):

$iBetragInCent = 230; 


$fAbgerundet = floor($iBetragInCent / 1); /** keine Gleitkommafehler **/ 

Für präzise Finanzberechnungen bietet PHP die BC-Math-Funktionen. Mit bcmul() vermeidest du Gleitkomma-Probleme vollständig:

<?php

$sErgebnis = bcmul('2.3', '100', 0);



echo floor((float) $sErgebnis); /** Ausgabe: 230 **/

5.2 Verhalten bei nicht-numerischen Eingaben

• Strings werden zu float/int konvertiert, was zu 0 führen kann.
• Arrays oder null geben einen Fehler zurück oder werden zu 0 gewandelt.

$sText = "abc"; 


echo floor($sText); /** Ausgabe: 0 (Warnung) **/ 

Best Practice:
Eingaben mit is_numeric() prüfen!

if (is_numeric($mWert)) { 


 $fErgebnis = floor($mWert); 


} else { 


 /** Fehlerbehandlung **/ 


} 

6. Erweiterte Anwendungsfälle für floor() in der Praxis

Gerade im Finanzbereich ist exaktes Abrunden essenziell, um Ungenauigkeiten bei der Cent-Berechnung oder Rundungsfehler bei Geldbeträgen konsequent zu vermeiden.

Finanzielle Berechnungen

Beispiel: Sicherstellen, dass nur ganze Centbeträge gezählt werden.

$fBetrag = 5.999; // Euro 


$iCents = floor($fBetrag * 100); 


/** Ergebnis: 599 Cents **/ 

Paginierung und Mengenangaben

Beispiel: Anzahl vollständiger Seiten berechnen.

$iGesamt = 53; 


$iProSeite = 10; 


$iVollseiten = floor($iGesamt / $iProSeite); 


/** Ergebnis: 5 **/ 

Zeitberechnungen

Beispiel: Sekunden in volle Minuten umwandeln.

$iSekunden = 185; 


$iMinuten = floor($iSekunden / 60); 


/** Ergebnis: 3 **/ 

Spielentwicklung: Rasterpositionierung

$fPosition = 9.82; 


/** Für Sprite-Raster immer abrunden: **/ 


$iRaster = floor($fPosition); 


/** Ergebnis: 9 **/ 

7. PHP-Versionskompatibilität und Änderungen (Changelog)

• floor() ist seit PHP 4 verfügbar.
• Seit PHP 8.0.0: floor() kann intern mit Objekten umgehen, die __toString() implementieren, ansonsten gibt es einen Fehler.
• In älteren PHP-Versionen: floor() gibt bei nicht-numerischen Werten null oder einen Fehler zurück.
• Seit PHP 8.0.0 gibt es fdiv(). Diese Funktion gibt bei Division durch Null INF statt einer Warnung zurück. In Kombination mit floor() ergibt das sichereren Code: floor(fdiv($a, $b)).

Empfehlung:
Immer Typen validieren, besonders bei gemischten Datentypen!

8. Häufig gestellte Fragen (FAQ)

Hier findest du Antworten auf die wichtigsten Fragen rund um floor().

Gibt floor() immer ein int zurück?

Nein. Obwohl floor() auf eine ganze Zahl abrundet, ist der Rückgabetyp float. Wenn du einen echten Integer brauchst, caste das Ergebnis:

$iWert = (int) floor(4.7); /** int(4) **/

Wie runde ich auf 2 Dezimalstellen ab?

Multipliziere mit 100, runde mit floor() ab und teile wieder durch 100:

<?php

$fPreis = 19.999;

$fAbgerundet = floor($fPreis * 100) / 100;



echo $fAbgerundet; /** Ausgabe: 19.99 **/

Wann nehme ich floor() und wann (int)?

floor() rundet immer Richtung minus unendlich, (int) schneidet Richtung Null ab. Bei positiven Zahlen ist das Ergebnis identisch. Bei negativen Zahlen nicht: floor(-3.2) ergibt -4, während (int) -3.2 ergibt -3. Willst du abschneiden statt abrunden, nimm (int).

9. Fazit: Wann ist floor() die richtige Wahl?

floor() ist das Werkzeug der Wahl, wenn du Zahlen zuverlässig nach unten abrunden willst. Das gilt für positive wie negative Werte gleichermaßen. Bei Pagination, Zeitberechnungen und finanziellen Rundungen ist floor() ein fester Bestandteil deines PHP-Werkzeugkastens.

Als schnelle Entscheidungshilfe: Brauchst du immer die nächstkleinere ganze Zahl, nimm floor(). Willst du kaufmännisch runden, nimm round(). Willst du Nachkommastellen abschneiden (Richtung Null), nimm (int)/intval(). Und bei sicherheitskritischen Berechnungen: Prüfe den Eingabetyp vorab und denke an die Gleitkomma-Problematik aus Abschnitt 5.1.