Werte von einem Typ in einen anderen zu bringen ist in PHP Alltag, sobald Formulardaten, JSON oder Datenbankwerte ins Spiel kommen. Dieser Beitrag dreht sich um PHP boolval und seine Geschwister floatval und settype und zeigt, welche Cast-Funktion bei welchem Eingabewert verlässlich das richtige Ergebnis liefert.
Cast-Operatoren vs Cast-Funktionen
Wer in PHP einen Wert in einen anderen Typ umwandeln will, hat zwei äquivalente Wege. Der Cast-Operator wie (float)$x oder (bool)$x ist kurz und in der C-Tradition vertraut. Die Cast-Funktion floatval($x) oder PHP boolval wirkt etwas ausführlicher, ist aber als Callable nutzbar, etwa in array_map, und bei manchen Lesern besser dokumentiert. Beide Wege liefern in normalen Fällen exakt dasselbe Ergebnis.
Bevor die Falsy-Werte-Tabelle und der Vergleich zu filter_var an die Reihe kommen, legt der nächste Absatz den thematischen Rahmen fest.
Dieses Tutorial geht den drei Cast-Helfern floatval(), boolval() und settype() auf den Grund, mit besonderem Fokus auf boolval() als wohl am meisten überraschende Funktion. intval() wird hier nur kurz erwähnt, weil die Funktion in unserem intval-Tutorial bereits ausführlich behandelt ist. Der Fokus liegt auf den anderen drei Funktionen plus dem Vergleich mit filter_var als RFC-nächster Lösung für Form- und JSON-Bool-Werte. Wer boolval() und filter_var sauber abgrenzt, baut deutlich robusteren Code.
floatval() und das deutsche Komma-Problem
floatval() wandelt einen Wert in einen Float um. Im einfachen Fall liefert die Funktion genau das, was man erwartet. Sobald aber deutsche Zahlen mit Komma-Trenner ins Spiel kommen, wird es unangenehm.
<?php
echo floatval('4.2'); /* 4.2 */
echo (float) '4.2'; /* 4.2, identisch */
echo floatval(' 3.14 '); /* 3.14, Whitespace egal */
echo floatval('abc'); /* 0 */
echo floatval('42abc'); /* 42, Parsing endet beim ersten ungueltigen Zeichen */
echo floatval('1.234,56'); /* 1.234, das Komma ist ein ungueltiges Zeichen */
Der letzte Fall ist die klassische Falle. Eine deutsche Eingabe wie 1.234,56 (Eintausendzweihundertvierunddreißig Komma fünfsechs) wird zu 1.234 reduziert, weil floatval nach englischer Konvention parsed. Ein kleiner Helper bringt die Daten in das von PHP erwartete Format.
<?php
function deutscherFloat(string $eingabe): float
{
$bereinigt = str_replace('.', '', $eingabe);
$bereinigt = str_replace(',', '.', $bereinigt);
return floatval($bereinigt);
}
echo deutscherFloat('1.234,56'); /* 1234.56 */
echo deutscherFloat('99,5'); /* 99.5 */
echo deutscherFloat('1.000.000,00'); /* 1000000 */
Der Helper ersetzt erst alle Punkte (Tausender-Trenner) durch nichts, dann das Komma durch einen Punkt. Das Ergebnis ist eine englisch-konforme Float-Notation, die floatval versteht. Wer mit Lokalisierung professioneller arbeitet, kann auf die NumberFormatter-Klasse aus dem intl-Modul ausweichen, die mit einem Locale-Code wie de_DE arbeitet.
PHP boolval und die Falsy-Werte-Tabelle
boolval() ist die wohl unterschätzteste Cast-Funktion. Die Logik hinter boolval() ist auf den ersten Blick simpel, hat aber eine bekannte Stolperfalle. Folgende Werte gelten in PHP als falsy: false, 0, 0.0, '' (leerer String), '0' (String mit Inhalt "0"), null, [] (leeres Array). Jeder andere Wert ist truthy. Genau dieses Mapping macht die Funktion zur Quelle häufiger Bugs, wenn der Eingabewert ein String wie "false" ist.
<?php
var_dump(boolval('')); /* false */
var_dump(boolval('0')); /* false (Spezialfall String "0") */
var_dump(boolval(0)); /* false */
var_dump(boolval(0.0)); /* false */
var_dump(boolval(null)); /* false */
var_dump(boolval([])); /* false */
var_dump(boolval('false')); /* true (!) String mit Inhalt */
var_dump(boolval('0.0')); /* true (!) String mit Inhalt */
var_dump(boolval('hallo')); /* true */
var_dump(boolval(42)); /* true */
var_dump(boolval([0])); /* true (Array nicht leer) */
Die Falle bei boolval() ist boolval('false'). Ein nicht-leerer String ist truthy, also wird der String "false" zu true. Genauso wird "0.0" zu true, weil der String drei Zeichen lang ist. Das ist konsistent mit PHPs allgemeinen Falsy-Regeln, überrascht aber jeden, der einen Form-Wert wie "true" oder "false" naiv durch die Funktion durchreicht. Wer das vermeiden will, nutzt entweder einen expliziten Vergleich oder die filter_var-Variante weiter unten.
boolval() ist seit PHP 5.5 verfügbar und identisch mit dem (bool)-Cast. Der Unterschied liegt nur in der Form: Als Funktion ist sie als Callable einsetzbar.
<?php
$werte = ['hallo', '', '0', '1', 0, 42];
$bools = array_map('boolval', $werte);
print_r($bools);
/* Array ( [0] => 1 [1] => [2] => [3] => 1 [4] => [5] => 1 ) */
Mit array_map und boolval als Funktionsnamen lässt sich eine ganze Liste in einem Schritt konvertieren. Mit dem Cast-Operator (bool) ginge das nur über eine Closure. Genau diese Eigenschaft macht boolval() und floatval() angenehm in funktionalen Pipelines, in denen Cast-Operatoren syntaktisch ungünstig wären.
settype() als In-Place-Konvertierung
settype() macht etwas, was die anderen Cast-Funktionen nicht können: Sie ändert eine Variable in-place. Der Rückgabewert ist nur ein true/false für Erfolg, der eigentliche Effekt steckt in der per Referenz übergebenen Variable.
<?php
$wert = '42';
var_dump($wert); /* string(2) "42" */
settype($wert, 'integer');
var_dump($wert); /* int(42) */
settype($wert, 'float');
var_dump($wert); /* float(42) */
settype($wert, 'string');
var_dump($wert); /* string(2) "42" */
settype() versteht die Typen 'integer', 'float' (alias 'double'), 'string', 'boolean', 'array', 'object' und 'null'. Bei 'array' wird der Wert in ein einelementiges Array verpackt, bei 'object' entsteht ein stdClass-Objekt mit einer scalar-Eigenschaft.
<?php
$x = 'hallo';
settype($x, 'array');
print_r($x); /* Array ( [0] => hallo ) */
$y = 42;
settype($y, 'object');
var_dump($y); /* object(stdClass)#1 (1) { ["scalar"]=> int(42) } */
Im Alltag nutzen die meisten Entwickler eher die Cast-Operatoren oder die spezifischen Funktionen, weil der Code dann lesbarer bleibt. settype() ist trotzdem nützlich, wenn der Typ dynamisch aus einer Konfiguration kommt und man nicht jede Variante mit einer if-Kette abbilden will.
flowchart TD
A[Eingabe pruefen] --> B{Welcher Zieltyp?}
B -->|Float| C[floatval oder cast]
B -->|Bool aus normalen Werten| D[boolval oder cast]
B -->|Bool aus 'true'/'false'| E[filter_var VALIDATE_BOOL]
B -->|In-place| F[settype]
C --> G[float]
D --> H[bool]
E --> H
F --> I[Variable im neuen Typ]
PHP boolval vs filter_var FILTER_VALIDATE_BOOL für Form-Daten
Sobald die Bool-Eingabe aus einem Formular oder einem JSON-API kommt, ist boolval() nicht mehr die richtige Wahl. Form-Felder enthalten meist Strings wie "true", "false", "yes", "no", "1", "0". Hier hilft filter_var mit dem Filter FILTER_VALIDATE_BOOL deutlich besser.
<?php
$werte = ['true', 'false', '1', '0', 'yes', 'no', 'on', 'off', 'abc'];
foreach ($werte as $w) {
$bool = filter_var($w, FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE);
printf("%-7s -> %s\n", $w, var_export($bool, true));
}
/*
true -> true
false -> false
1 -> true
0 -> false
yes -> true
no -> false
on -> true
off -> false
abc -> NULL
*/
Der Filter kennt die typischen Form-Konventionen und liefert true, false oder bei FILTER_NULL_ON_FAILURE null, wenn die Eingabe gar nicht als Boolean interpretierbar ist. Damit lassen sich klare drei-Wege-Prüfungen bauen: Wert ist true, false oder ungültig. Mehr zu filter_var und der Filter-Familie steht im Eingabe-Filtern-Tutorial.
Cast-Funktionen in declare(strict_types=1)
Wer mit dem strikten Typmodus arbeitet, profitiert von den expliziten Cast-Funktionen. Im strict-Mode wirft PHP einen TypeError, wenn eine Funktion mit int-Parameter einen Float bekommt. Die explizite Konvertierung mit floatval(), intval() oder boolval() macht klar, dass die Konvertierung beabsichtigt ist. Im Code-Review erkennt der Leser sofort, dass an dieser Stelle bewusst gecastet wurde, statt sich auf eine implizite Magie zu verlassen.
<?php
declare(strict_types=1);
function rabatt(float $betrag): float
{
return $betrag * 0.9;
}
$eingabe = '100';
echo rabatt(floatval($eingabe)); /* 90 */
/* Ohne floatval: TypeError */
Im strict-Mode sind die Funktionen nicht nur Stilfrage, sondern oft notwendig. Im nicht-strikten Modus würde PHP automatisch konvertieren, im strict-Modus ist die explizite Konvertierung Pflicht.
Best Practices für PHP boolval und floatval
Vier Punkte sind im Alltag wichtig. Erstens: boolval('false') ist true. Wer aus Form- oder API-Daten echte Booleans braucht, nutzt filter_var mit FILTER_VALIDATE_BOOL statt boolval(). Zweitens: floatval parsed nur das vorderste Zahlenstück und ignoriert den Rest. Bei deutschen Zahlen mit Komma ist Vorab-Bereinigung Pflicht. Drittens: settype ändert die Variable in-place, das ist nützlich, kann aber auch überraschen, wenn die Variable an anderer Stelle als String erwartet wird. Eine kurze Code-Notiz im Stil /* settype: Variable wird zu int */ schadet nicht.
Viertens: In strict-Mode-Skripten lohnen sich die Cast-Funktionen mehr als die Cast-Operatoren, weil sie klarmachen, dass die Konvertierung gewollt ist. Im Code-Review ist floatval($eingabe) deutlicher als (float) $eingabe, auch wenn beide funktional identisch sind. Für eine vollständige Sicht auf Typsicherheit lohnt sich unser Tutorial zu Type Hints und strict_types.
Fazit
Die in diesem Tutorial gezeigten Beispiele decken die wichtigsten Praxisfälle ab. floatval(), boolval() und settype() sind die drei wichtigsten Cast-Funktionen in PHP, die wir hier behandelt haben. boolval() verhält sich nach den allgemeinen Falsy-Regeln und liefert für den String "false" trotzdem true, was die häufigste Stolperfalle ist. floatval parst englisch und braucht für deutsche Zahlen einen kleinen Helper. settype ändert eine Variable in-place und ist dann nützlich, wenn der Zieltyp dynamisch festgelegt wird. Für Bool-Eingaben aus Form- oder JSON-Quellen ist filter_var mit FILTER_VALIDATE_BOOL die bessere Wahl, weil es Strings wie "true", "yes" und "off" sauber interpretiert. Wer all diese Werkzeuge kennt, baut robuste Typumwandlung für User-Input und Datenbankwerte und vermeidet die typischen Bugs rund um die PHP-Bool-Konvertierung.
