PHP Datentypen: int, float, string, bool, array, null

PHP hat acht Typen, die du jeden Tag verwendest: int, float, string, bool, array, object, null und dazu callable für Funktionen, die du weitergibst. Eine Variable hat keinen festen Typ; ihr aktueller Wert hat einen. var_dump($x) zeigt Typ und Wert, und gettype($x) liefert den Typ als String.

<?php
$values = [42, 3.14, "hello", true, [1, 2, 3], null, new stdClass()];

printf("%-8s %-10s %s\n", "gettype", "debug", "value");
foreach ($values as $value) {
    printf("%-8s %-10s %s\n", gettype($value), get_debug_type($value), json_encode($value));
}

Die erste Spalte ist gettype(), die zweite get_debug_type(). Ersetze einen Wert durch einen eigenen und führe den Code erneut aus. Bei einigen Namen sind sich die beiden uneinig: gettype sagt aus historischen Gründen integer, double und boolean, während get_debug_type die Namen aus Typdeklarationen verwendet (int, float, bool) und bei einem Objekt den Klassennamen liefert.

Die PHP-Typen im Überblick

Werte mit var_dump untersuchen

var_dump ist das Werkzeug, um zu sehen, was du wirklich hast. Es gibt den Typ, den Wert und bei Strings die Länge in Bytes aus:

<?php
var_dump(10);
var_dump(10.0);
var_dump("10");
var_dump(true);
var_dump(null);
var_dump(["id" => 7, "tags" => ["php", "web"]]);
var_dump("café");   // 5 bytes: é takes two bytes in UTF-8

echo würde bei den ersten drei 10 ausgeben und den Unterschied verstecken. Die Länge in string(5) "café" zählt Bytes, und deshalb unterscheiden sich strlen und mb_strlen bei Nicht-ASCII-Text.

Ganzzahlen und Floats

Eine Ganzzahl ist eine ganze Zahl. Literale dürfen zur besseren Lesbarkeit Unterstriche enthalten und in Hex-, Oktal- oder Binärschreibweise stehen. Ein Float ist jede Zahl mit Dezimalpunkt oder Exponent, und wie in jeder Sprache speichert er die meisten Dezimalzahlen nur näherungsweise:

<?php
$population = 8_100_000_000;   // underscores are ignored
var_dump($population);
var_dump(0xFF, 0b1010, 0o17);  // hex, binary, octal
var_dump(PHP_INT_MAX);
var_dump(PHP_INT_MAX + 1);     // too big: becomes a float

var_dump(7 / 2);               // / returns a float when needed
var_dump(8 / 2);               // and an int when the result is whole
var_dump(intdiv(7, 2));        // integer division

var_dump(0.1 + 0.2);
var_dump(0.1 + 0.2 == 0.3);
var_dump(abs((0.1 + 0.2) - 0.3) < PHP_FLOAT_EPSILON);

Vergleiche Floats nie mit ==; vergleiche die Differenz mit einer kleinen Toleranz oder runde vorher beide Seiten. Für Geldbeträge speicherst du ganze Cent als Ganzzahlen.

Booleans und welche Werte false sind

Ein bool ist true oder false. Wo PHP eine Bedingung erwartet (if, while, !), wird jeder Wert in bool umgewandelt, und eine kurze Liste von Werten zählt als false: false, 0, 0.0, "", "0", [] und null. Alles andere ist true. Die Tabelle zeigt jeden Wert mit seinem Typ, seiner Umwandlung in bool und ob er numerisch ist:

Die Überraschungen sind "0.0", " " und "null": Alle drei sind nicht leere Strings und nicht "0", also sind sie true, und if ($value) führt für sie den Rumpf aus.

Arrays, Objekte und null

Ein Array enthält eine beliebige Mischung von Werten unter Ganzzahl- oder String-Schlüsseln. Ein Objekt ist eine Instanz einer Klasse; stdClass ist PHPs leere Klasse für schnelle Objekte, und (object) macht aus einem Array ein Objekt. null bedeutet „kein Wert“:

<?php
$user = ["name" => "Ada", "roles" => ["admin", "editor"]];
echo gettype($user), ": ", $user["name"], "\n";

$point = new stdClass();
$point->x = 3;
$point->y = 4;
echo get_debug_type($point), ": ", $point->x, ",", $point->y, "\n";

$config = (object) ["debug" => true];
echo get_debug_type($config), ": debug is ", var_export($config->debug, true), "\n";

class Product
{
    public function __construct(public string $name, public float $price) {}
}
$p = new Product("Lamp", 25.0);
echo get_debug_type($p), ": {$p->name}\n";

$nothing = null;
var_dump($nothing, is_null($nothing));

Einen Typ mit is_*-Funktionen prüfen

Für jeden Typ gibt es eine Testfunktion, die true oder false zurückgibt. is_numeric ist etwas anderes als is_int: Es akzeptiert auch numerische Strings, und genau das willst du beim Prüfen von Formulareingaben.

<?php
$tests = [5, 5.0, "5", "5.5", " 5", "abc", true, null];

printf("%-7s %-6s %-8s %-9s %-10s\n", "value", "is_int", "is_float", "is_string", "is_numeric");
foreach ($tests as $t) {
    printf(
        "%-7s %-6s %-8s %-9s %-10s\n",
        var_export($t, true),
        is_int($t) ? "yes" : "",
        is_float($t) ? "yes" : "",
        is_string($t) ? "yes" : "",
        is_numeric($t) ? "yes" : ""
    );
}

Weitere: is_bool, is_array, is_object, is_null, is_callable, is_iterable und $x instanceof ClassName für eine bestimmte Klasse.

Typumwandlung und strikte Typen

PHP wandelt Typen automatisch um, wenn ein Operator einen anderen braucht. Ein numerischer String in einer Rechnung wird zur Zahl, und . macht aus Zahlen Strings. Ein String, der gar nicht numerisch ist, lässt sich nicht addieren, und PHP 8 wirft einen TypeError:

<?php
var_dump("10" + 5);        // int(15)
var_dump("1.5" * 2);       // float(3)
var_dump(10 . " items");   // string
var_dump("10" == "1e1");   // both numeric strings: compared as numbers
var_dump(100 == "1e2");

try {
    var_dump("abc" + 1);
} catch (TypeError $e) {
    echo "TypeError: ", $e->getMessage(), "\n";
}

Typisierte Parameter wandeln ebenfalls um, außer die Datei beginnt mit declare(strict_types=1);. Dann schlägt ein Aufruf mit dem falschen skalaren Typ fehl, statt umgewandelt zu werden:

<?php
declare(strict_types=1);

function addVat(float $net): float
{
    return $net * 1.2;
}

echo addVat(100), "\n";          // int to float is still allowed

try {
    echo addVat("100"), "\n";    // a string is not converted in strict mode
} catch (TypeError $e) {
    echo "TypeError: ", $e->getMessage(), "\n";
}

Um bewusst umzuwandeln, castest du: (int) "42", (float) "3.5", (string) 10, (bool) "0". Die Seite zu Type Casting behandelt jeden Cast und seine Sonderfälle.

Typischer Fehler: verschiedene Typen mit == vergleichen

Weil == vor dem Vergleich umwandelt, können zwei Werte verschiedener Typen auf eine Weise „gleich“ sein, die zu Bugs führt, etwa "1e1" == "10" (beides ist die Zahl 10) oder null == false. Verwende ===, das zusätzlich denselben Typ verlangt, außer du willst die Umwandlung:

<?php
$pairs = [["1e1", "10"], [null, false], [0, ""], ["abc", 0], [1.0, 1]];

foreach ($pairs as [$a, $b]) {
    $show = var_export($a, true) . " vs " . var_export($b, true);
    printf("%-16s ==  %-6s ===  %s\n", $show, var_export($a == $b, true), var_export($a === $b, true));
}

PHP 8 hat den schlimmsten Fall behoben: "abc" == 0 war früher true und ist jetzt false, weil ein nicht numerischer String als String verglichen wird. Die vollständigen Tabellen stehen auf der Seite zu Vergleichsoperatoren.