isset()

Introduction

Le construct isset() est un construct de langage intégré en PHP qui vérifie si une variable a été définie. Il retourne true si la variable existe et n'est pas null, et false dans le cas contraire.

La chose essentielle à comprendre est que isset() s'intéresse uniquement à l'existence, et non à la véracité. Il retourne true même lorsque la valeur est 0, false, "0", ou une chaîne vide "" — il retourne false uniquement pour les variables qui n'ont jamais été définies, qui ont été désaffectées, ou qui contiennent null.

Cela fait de isset() la méthode sûre pour tester les clés de tableau et les champs de formulaire avant de les lire, en évitant les avertissements "Undefined variable" et "Undefined array key" que PHP émet lorsque vous accédez à quelque chose qui n'existe pas.

Cette page couvre la syntaxe de isset(), son comportement avec null, 0 et les clés de tableau manquantes, la façon de vérifier plusieurs variables à la fois, et en quoi il diffère des fonctions connexes empty(), is_null() et array_key_exists().

Syntaxe

La syntaxe du construct isset() est la suivante :

La syntaxe PHP de isset()

bool isset(mixed $var [, mixed $... ])

Le construct accepte un ou plusieurs paramètres, $var et des paramètres supplémentaires optionnels séparés par des virgules. Chaque paramètre représente une variable à vérifier. Le construct retourne true si toutes les variables existent et ne sont pas null, et false dans le cas contraire.

Exemple d'utilisation

Voici un exemple d'utilisation du construct isset() en PHP :

Exemple de isset() en PHP

<?php
$var1 = "hello";
$var2 = null;
$var3 = 0;
$array = ['key' => 'value'];

if (isset($var1)) {
    echo '$var1 is set and is not null' . "\n";
}
if (isset($var2)) {
    echo '$var2 is set and is not null' . "\n";
} else {
    echo '$var2 is not set or is null' . "\n";
}
if (isset($var3)) {
    echo '$var3 is set (value is 0)' . "\n";
}
if (isset($array['key'])) {
    echo "Array key 'key' is set" . "\n";
}
?>

Dans cet exemple, nous définissons plusieurs variables et un tableau. Nous utilisons le construct isset() pour vérifier si chaque variable ou clé de tableau est définie. La première instruction if retourne true car $var1 est définie. La deuxième instruction if retourne false car $var2 est null, donc le bloc else s'exécute. La troisième instruction if retourne true car $var3 est définie à 0 (ce qui démontre que isset() vérifie l'existence, et non la véracité). La quatrième instruction if retourne true car la clé de tableau 'key' existe.

Vérifier plusieurs variables à la fois

isset() accepte plusieurs arguments et retourne true uniquement lorsque chaque argument est défini et non null. Dès qu'un seul d'entre eux est manquant ou null, l'appel entier retourne false. C'est pratique pour valider qu'un groupe de valeurs requises est entièrement présent avant de continuer :

<?php
$name  = "Ada";
$email = "[email protected]";
$phone = null;

if (isset($name, $email)) {
    echo "Both name and email are set" . "\n";
}

if (isset($name, $email, $phone)) {
    echo "All three are set" . "\n";
} else {
    echo "At least one of name, email, phone is missing or null" . "\n";
}
?>

Comme $phone est null, le deuxième isset() retourne false même si les deux autres variables sont définies.

Tableaux imbriqués et clés manquantes

Une raison courante d'utiliser isset() est la lecture de données profondément imbriquées, comme $_POST ou une structure JSON décodée, où n'importe quel niveau peut être absent. isset() effectue un court-circuit de manière sécurisée : si une clé intermédiaire n'existe pas, il retourne false au lieu de déclencher un avertissement.

<?php
$user = [
    'profile' => [
        'name' => 'Grace',
    ],
];

var_dump(isset($user['profile']['name']));   // bool(true)
var_dump(isset($user['profile']['age']));    // bool(false) - key missing
var_dump(isset($user['settings']['theme'])); // bool(false) - 'settings' missing entirely
?>

Notez que isset() retourne false pour une clé existante dont la valeur est null. Si vous devez distinguer "la clé existe mais contient null" de "la clé n'existe pas", utilisez array_key_exists() à la place.

isset() vs empty(), is_null() et array_key_exists()

Ces quatre fonctions sont faciles à confondre. Le tableau montre ce que chacune retourne pour une variable $x contenant différentes valeurs :

Points clés à retenir :

• Utilisez isset() lorsque vous voulez savoir si quelque chose existe et n'est pas null — il ne déclenche jamais d'avertissement pour les variables non définies.
• Utilisez empty() lorsque vous voulez savoir si une valeur est "falsy" (0, "", null, false, tableau vide, etc.).
• Utilisez is_null() lorsque vous vous intéressez spécifiquement à la valeur null — notez toutefois qu'il génère un avertissement si la variable n'a jamais été définie.
• Utilisez array_key_exists() lorsqu'une clé peut légitimement contenir null et que vous avez quand même besoin de détecter sa présence.

Le raccourci de coalescence null

Depuis PHP 7, l'opérateur de coalescence null ?? est une alternative concise à une vérification isset() suivie d'une valeur de repli. L'expression $a ?? $b s'évalue à $a si elle est définie et non null, sinon à $b — sans aucun avertissement :

<?php
$config = ['timeout' => 30];

// Verbose: explicit isset()
$retries = isset($config['retries']) ? $config['retries'] : 5;
echo $retries . "\n"; // 5

// Concise: same result with the ?? operator
$timeout = $config['timeout'] ?? 60;
echo $timeout . "\n"; // 30
?>

Privilégiez ?? lorsque vous avez simplement besoin d'une valeur par défaut ; conservez isset() lorsque vous avez besoin du résultat booléen lui-même, par exemple dans une condition plus large.

Conclusion

Le construct isset() est un outil utile pour vérifier si une variable a été définie en PHP. Il peut être utilisé pour s'assurer qu'une variable existe avant d'effectuer des opérations sur elle, ou pour gérer les variables définies et non définies d'une manière particulière. En utilisant ce construct, les développeurs peuvent s'assurer que leur code travaille avec les données attendues et éviter les erreurs qui peuvent survenir lors de l'utilisation de valeurs null.

Pratique