gettype PHP: Comment puis-je afficher le type d’une variable en PHP ?

Qu’est-ce que gettype() et à quoi sert-elle ?

gettype() est une fonction native de PHP qui identifie le type d’une variable et retourne ce résultat sous forme de chaîne de caractères exploitable dans votre code. Elle couvre l’ensemble des types du langage : scalaires, tableaux, objets, ressources et valeur nulle.

Son usage principal est le diagnostic de variables dont le type peut varier selon le chemin d’exécution du script, par exemple une valeur issue d’un formulaire HTML ou d’une réponse d’API externe. Elle permet de prendre une décision conditionnelle ou de journaliser le type réel d’une donnée à un instant précis.

Contrairement à var_dump() qui affiche simultanément type et valeur sans retourner de résultat réutilisable, gettype() retourne une chaîne assignable à une variable ou comparable dans un bloc switch. Cette flexibilité la distingue des fonctions purement orientées affichage comme print_r().

La documentation officielle PHP recommande néanmoins de préférer les fonctions is_*() pour les vérifications conditionnelles, car elles retournent directement un booléen sans risque d’erreur typographique sur la chaîne de comparaison. gettype() reste pertinente pour l’affichage, la journalisation ou le routage dynamique selon le type d’une variable inconnue.

Syntaxe et valeurs retournées

gettype() reçoit un seul argument obligatoire de type mixed, ce qui lui permet d’accepter n’importe quelle donnée PHP sans déclencher d’erreur de typage à l’appel.

phpgettype(mixed $value): string

La fonction retourne l’une des dix chaînes suivantes, dont certaines sont des noms historiques conservés pour des raisons de compatibilité ascendante :

Valeur retournée	Type PHP correspondant
"boolean"	bool
"integer"	int
"double"	float (nom historique)
"string"	string
"array"	array
"object"	Toute instance de classe
"resource"	Ressource active
"resource (closed)"	Ressource fermée (PHP 7.2+)
"NULL"	null
"unknown type"	Type non reconnu

Le cas le plus piégeux est celui des flottants : gettype() retourne "double" et non "float", héritage des premières versions de PHP. Toute comparaison avec la chaîne "float" produira silencieusement false sans générer d’avertissement, ce qui en fait une source d’erreur difficile à détecter.

Passer une variable non initialisée ne provoque pas d’erreur fatale mais génère un avertissement E_WARNING. Combinez isset() et gettype() pour une vérification robuste dans les contextes où l’existence de la variable n’est pas garantie.

L’exemple suivant illustre les chaînes retournées sur les types les plus courants rencontrés dans un projet PHP.

<?php
$entier   = 42;
$flottant = 3.14;
$chaine   = "Bonjour";
$booleen  = true;
$tableau  = ["PHP", "MySQL"];
$objet    = new stdClass();
$nul      = null;

var_export([
    gettype($entier),   // "integer"
    gettype($flottant), // "double"
    gettype($chaine),   // "string"
    gettype($booleen),  // "boolean"
    gettype($tableau),  // "array"
    gettype($objet),    // "object"
    gettype($nul),      // "NULL"
]);
?>

La sortie confirme que gettype() retourne "double" pour un flottant et "boolean" en toutes lettres pour un booléen, contrairement aux alias modernes float et bool utilisés dans les déclarations de type PHP 8. Mémorisez ces noms historiques pour éviter tout comportement inattendu dans vos comparaisons de chaînes. Utilisez var_export() ici à la place de var_dump() pour obtenir une sortie directement comparable avec les valeurs attendues.

gettype() dans un bloc switch

gettype() s’intègre naturellement dans un bloc switch pour orienter le traitement d’une variable selon son type détecté à l’exécution. Ce pattern est courant dans les fonctions utilitaires qui reçoivent un argument de type mixed et doivent adapter leur comportement en conséquence.

Cette approche est plus lisible qu’une chaîne de conditions if/elseif imbriquées lorsque le nombre de types à gérer dépasse trois cas distincts. Elle centralise également la gestion des types inattendus dans un unique cas default.

<?php
function formaterValeur(mixed $valeur): string
{
    switch (gettype($valeur)) {
        case "integer":
            return number_format($valeur, 0, ',', ' ');
        case "double":
            return number_format($valeur, 2, ',', ' ');
        case "string":
            return htmlspecialchars(trim($valeur));
        case "boolean":
            return $valeur ? "Activé" : "Désactivé";
        case "array":
            return implode(", ", $valeur);
        case "NULL":
            return "—";
        default:
            return "[type non pris en charge : " . gettype($valeur) . "]";
    }
}

echo formaterValeur(1500000);    // 1 500 000
echo formaterValeur(49.9);       // 49,90
echo formaterValeur("  PHP  ");  // PHP
echo formaterValeur(true);       // Activé
echo formaterValeur(null);       // —
?>

La fonction formaterValeur() adapte la mise en forme de la donnée transmise selon son type réel, sans jamais supposer ce que l’appelant a fourni. Le cas default capture tout type résiduel comme un objet ou une ressource en retournant un message explicite plutôt qu’en échouant silencieusement. Vérifiez systématiquement que vos cas switch utilisent les noms historiques comme "double" et "boolean" pour que les comparaisons soient évaluées correctement.

gettype() versus get_debug_type()

Depuis PHP 8.0, la fonction get_debug_type() a été introduite pour moderniser l’identification des types en retournant des noms canoniques alignés sur la syntaxe PHP actuelle. Elle résout directement le problème des noms historiques de gettype() qui créent des incompatibilités avec les outils de réflexion et les déclarations de type modernes.

Pour les objets, get_debug_type() retourne le nom complet de la classe avec son namespace, ce que gettype() ne fait pas en retournant simplement "object". Cette précision supplémentaire est précieuse pour déboguer des architectures orientées objet complexes avec plusieurs niveaux de namespaces.

<?php
namespace App\Service;

class FactureService {}

$service  = new FactureService();
$flottant = 3.14;
$booleen  = false;

// gettype()
echo gettype($service);  // object
echo gettype($flottant); // double
echo gettype($booleen);  // boolean

// get_debug_type()
echo get_debug_type($service);  // App\Service\FactureService
echo get_debug_type($flottant); // float
echo get_debug_type($booleen);  // bool
?>

get_debug_type() retourne le namespace complet de l’objet, permettant d’identifier précisément quelle classe est impliquée dans un bug. Les noms "float" et "bool" correspondent aux alias modernes utilisés dans les déclarations de type PHP 8, éliminant toute confusion avec les noms historiques. Adoptez get_debug_type() dans tout nouveau projet PHP 8+ et conservez gettype() uniquement pour maintenir une compatibilité avec du code PHP 7 existant.

gettype() versus les fonctions is_*()

Les fonctions is_*() constituent l’alternative recommandée pour vérifier le type d’une variable dans une condition. Elles retournent directement un booléen sans passer par une comparaison de chaînes, ce qui élimine le risque d’écrire "int" au lieu de "integer" dans votre code avec la fonction is_int() par exemple.

La lisibilité est également en faveur des fonctions is_*() : is_float($valeur) exprime clairement l’intention du développeur, tandis que gettype($valeur) === "double" exige de connaître le nom historique du type. Ce type d’écart entre le nom attendu et le nom retourné est une source classique de bugs silencieux en PHP.

<?php
$prix = 49.90;

// Approche avec gettype() — risque d'erreur sur le nom
if (gettype($prix) === "double") {
    echo "Prix valide";
}

// Approche recommandée avec is_float()
if (is_float($prix)) {
    echo "Prix valide";
}

// Tableau de diagnostic : gettype() reste utile ici
$variables = [42, 3.14, "PHP", true, null, []];
foreach ($variables as $var) {
    echo gettype($var) . " : ";
    var_export($var);
    echo "\n";
}
?>

Les deux conditions produisent le même résultat sur $prix, mais is_float() ne dépend d’aucune connaissance des noms historiques de PHP. La boucle foreach en bas de l’exemple illustre le cas où gettype() reste le meilleur choix : générer un rapport de types sur un ensemble de valeurs hétérogènes. Appliquez cette règle simple : is_*() pour les conditions logiques, gettype() pour l’affichage et la journalisation.

Sources: PHPnet