Types de données PHP : int, float, string, bool, array, null

PHP a huit types que vous utilisez tous les jours : int, float, string, bool, array, object, null, plus callable pour les fonctions que vous faites circuler. Une variable n'a pas de type fixe ; c'est sa valeur actuelle qui en a un. var_dump($x) montre à la fois le type et la valeur, et gettype($x) renvoie le type sous forme de chaîne.

<?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));
}

La première colonne vient de gettype(), la seconde de get_debug_type(). Remplacez une valeur par la vôtre et relancez. Elles divergent sur quelques noms : gettype dit integer, double et boolean pour des raisons historiques, tandis que get_debug_type utilise les noms des déclarations de type (int, float, bool) et donne le nom de la classe pour un objet.

Les types PHP en un coup d'œil

Inspecter des valeurs avec var_dump

var_dump est l'outil pour voir ce que vous avez vraiment. Il affiche le type, la valeur, et pour les chaînes la longueur en octets :

<?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 afficherait 10 pour les trois premières et cacherait la différence. La longueur dans string(5) "café" compte des octets, c'est pourquoi strlen et mb_strlen diffèrent pour du texte non ASCII.

Entiers et floats

Un entier est un nombre sans partie décimale. Les littéraux peuvent contenir des tirets bas pour la lisibilité, et s'écrire en hexadécimal, octal ou binaire. Un float est un nombre avec un point décimal ou un exposant, et comme dans tous les langages il stocke la plupart des décimaux de façon approchée :

<?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);

Ne comparez jamais des floats avec == ; comparez leur différence à une petite tolérance, ou arrondissez d'abord les deux côtés. Pour de l'argent, stockez des centimes entiers.

Les booléens et les valeurs fausses

Un bool vaut true ou false. Là où PHP attend une condition (if, while, !), toute valeur est convertie en bool, et une courte liste de valeurs compte comme fausse : false, 0, 0.0, "", "0", [] et null. Tout le reste est vrai. Le tableau montre chaque valeur avec son type, sa conversion en bool et si elle est numérique :

Les surprises sont "0.0", " " et "null" : ce sont trois chaînes non vides différentes de "0", donc elles sont vraies, et if ($value) exécute son corps pour elles.

Tableaux, objets et null

Un tableau contient n'importe quel mélange de valeurs sous des clés entières ou de type chaîne. Un objet est une instance d'une classe ; stdClass est la classe vide de PHP pour créer des objets rapidement, et (object) transforme un tableau en objet. null signifie « aucune valeur » :

<?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));

Vérifier un type avec les fonctions is_*

Chaque type a une fonction de test qui renvoie true ou false. is_numeric diffère de is_int : elle accepte aussi les chaînes numériques, ce qu'il faut pour vérifier une saisie de formulaire.

<?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" : ""
    );
}

Les autres : is_bool, is_array, is_object, is_null, is_callable, is_iterable, et $x instanceof ClassName pour une classe précise.

Conversions implicites et types stricts

PHP convertit automatiquement les types quand un opérateur en attend un autre. Une chaîne numérique utilisée dans un calcul devient un nombre, et . transforme les nombres en chaînes. Une chaîne qui n'a rien de numérique ne peut pas être additionnée, et PHP 8 lève une 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";
}

Les paramètres typés convertissent aussi, sauf si le fichier commence par declare(strict_types=1);. Dans ce cas, un appel avec le mauvais type scalaire échoue au lieu d'être converti :

<?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";
}

Pour convertir volontairement, faites un cast : (int) "42", (float) "3.5", (string) 10, (bool) "0". La page sur le transtypage couvre chaque cast et ses cas limites.

Erreur fréquente : comparer des types différents avec ==

Comme == convertit avant de comparer, deux valeurs de types différents peuvent être « égales » d'une manière qui provoque des bugs, comme "1e1" == "10" (les deux valent le nombre 10) ou null == false. Utilisez ===, qui exige aussi le même type, sauf si vous voulez la conversion :

<?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 a corrigé le pire cas : "abc" == 0 valait true et vaut désormais false, car une chaîne non numérique est comparée comme une chaîne. Les tableaux complets sont sur la page des opérateurs de comparaison.