is object en PHP: Comment vérifier si un objet existe en PHP ?

La fonction is_object() permet de déterminer si une variable contient une instance d’objet en PHP. Elle fait partie des fonctions d’inspection de type natives du langage, utilisables sans configuration préalable.

Syntaxe générique et comportement de la fonction is object en PHP

is_object() accepte un seul argument obligatoire de type mixed, ce qui lui permet de recevoir n’importe quelle valeur PHP : chaîne, tableau, entier ou valeur nulle.

is_object(mixed $value): bool

La fonction n’effectue aucune conversion implicite sur la valeur transmise, garantissant ainsi une lecture fidèle du type réel de la variable. Elle retourne true si la valeur est une instance d’objet, et false pour tout autre type, sans résultat intermédiaire.

Passer une variable non initialisée ne provoque pas d’erreur fatale, mais génère un avertissement PHP qu’il est préférable d’éviter. Assurez-vous donc que la variable est correctement définie avant tout appel à is_object().

Pour contrôler plusieurs variables, vous devez appeler la fonction séparément pour chacune d’elles, car elle ne prend pas en charge plusieurs arguments simultanément. Ce comportement strict et binaire la rend particulièrement fiable dans les structures conditionnelles et la validation de données entrantes.

Comment vérifier si le type est un objet en PHP  ?

Une instance de classe est créée avec le mot-clé new en PHP. Dès qu’une variable reçoit cette instance, is_object() la reconnaît comme un objet valide et retourne true.

Voici comment la fonction réagit face à différentes instances :

<?php
class Utilisateur
{
    public string $nom = "Alice";
}

$user   = new Utilisateur();
$stdObj = new stdClass();

var_dump(is_object($user));   // bool(true)
var_dump(is_object($stdObj)); // bool(true)
?>

Les deux appels retournent true car $user et $stdObj sont des instances valides. stdClass est la classe générique de PHP, fréquemment utilisée pour construire des objets anonymes à la volée sans déclarer de classe dédiée.

Tester is_object() avec des types non objets

La fonction retourne false pour tout type qui n’est pas strictement un object. Les chaînes de caractères, les entiers, les tableaux et les booléens sont tous écartés, même lorsqu’ils semblent structurés comme un objet.

Maîtriser ce comportement est essentiel pour prévenir des erreurs de validation silencieuses dans vos scripts PHP.

<?php
$chaine  = "Alice";
$entier  = 42;
$tableau = ["nom" => "Alice"];
$booleen = true;

var_dump(is_object($chaine));  // bool(false)
var_dump(is_object($entier));  // bool(false)
var_dump(is_object($tableau)); // bool(false)
var_dump(is_object($booleen)); // bool(false)
?>

Chaque évaluation retourne false car aucune de ces variables n’est de type object. Le tableau associatif est particulièrement trompeur : sa structure clé/valeur imite un objet en apparence, mais reste un type array aux yeux du moteur PHP.

Le comportement de is_object() avec null

Passer null à is_object() retourne systématiquement false, même si la variable a été initialisée au préalable. Ce point est crucial à anticiper lorsqu’une variable est susceptible d’être nullable dans votre application.

À partir de PHP 7.2, un objet reconstruit depuis des données sérialisées reste reconnu comme tel par is_object(), même si sa classe d’origine n’est plus chargée en mémoire. Cette évolution affecte les projets qui manipulent des données sérialisées sans charger l’intégralité de leurs classes.

<?php
$objetValide = new stdClass();
$objetNul    = null;

var_dump(is_object($objetValide)); // bool(true)
var_dump(is_object($objetNul));    // bool(false)
?>

Le premier appel confirme la présence d’une instance valide. Le second retourne false car null ne représente aucune instance d’objet, indépendamment de la version de PHP utilisée.

Cas pratique : sécuriser l’accès aux propriétés d’un objet avec is_object()

Accéder à une propriété sans vérifier le type de la variable peut provoquer une erreur fatale si cette dernière ne contient pas d’objet. Utiliser is_object() en amont sécurise cet accès et renforce la robustesse du code face aux données inattendues ou malformées.

<?php
function afficherNomUtilisateur(mixed $data): string
{
    if (!is_object($data)) {
        return "Erreur : la donnée transmise n'est pas un objet valide.";
    }

    if (!isset($data->nom)) {
        return "Erreur : la propriété 'nom' est absente de l'objet.";
    }

    return "Nom de l'utilisateur : " . $data->nom;
}

$user      = new stdClass();
$user->nom = "Alice";

echo afficherNomUtilisateur($user);   // Nom de l'utilisateur : Alice
echo afficherNomUtilisateur("Alice"); // Erreur : la donnée transmise n'est pas un objet valide.
echo afficherNomUtilisateur(null);    // Erreur : la donnée transmise n'est pas un objet valide.
?>

La vérification initiale bloque toute variable qui ne correspond pas à une instance d’objet valide. Le second contrôle sur la présence de la propriété nom anticipe les objets incomplets, renforçant ainsi la fiabilité du traitement des données dans votre application.

Sources: PHPnet