La fonction isset en PHP permet de vérifier que le nom de la variable existe et qu’elle n’est pas null, évitant ainsi notices, erreurs et comportements inattendus.Elle renvoie true si la variable est définie et différente de null, sinon false. Elle peut être utilisée avec une ou plusieurs variables dans le même appel. Cependant, il est préférable dans certains cas d’utiliser d’autres fonction telles que empty.
Table des matières
Signature de la fonction isset en PHP
isset(mixed $var, mixed ...$vars): boolCette fonction peut prendre un ou plusieurs paramètres. Avec un seul paramètre, elle évaluera si la variable est définie ou non. En revanche, si on lui donne plusieurs paramètres, elle vérifiera si l’intégralité des paramètre existe ou non. Il est donc important de savoir ce que l’on veut faire dans notre script PHP.
<?php
$var = 'Bonjour';
// Exemple simple
if (isset($var)) {
echo "La variable \$var est définie et n'est pas null.";
} else {
echo "La variable \$var n'est pas définie ou vaut null.";
}
// Exemple avec plusieurs variables
$a = 1;
$b = null;
if (isset($a, $b)) {
echo "Les variables \$a et \$b sont toutes les deux définies et non null.";
} else {
echo "Au moins une des variables \$a ou \$b n'est pas définie ou vaut null.";
}Dans ce snippet, isset($var) renvoie true car $var contient une chaîne de caractères. En revanche, dans le second test de notre code-source, isset($a, $b) renverra false parce que $b vaut null.
Comment utiliser isset en PHP avec les formulaires ?
Les formulaires HTML sont une des premières sources de variables dynamiques en PHP. Avant d’utiliser une variable issue de $_POST ou $_GET, il est préférable de vérifier sa présence. Dans les scripts PHP, la fonction isset accepte les types de données tels que les chaînes de caractères ou string en anglais, les entiers, les tableaux ou array , les constantes et autres.
Vérifier si un formulaire a été soumis ?
<?php
if (isset($_POST['submit'])) {
echo "Le formulaire a été soumis.";
// Ici, tu peux traiter les données du formulaire
} else {
echo "Formulaire non soumis.";
}Ici, on suppose que le bouton de soumission du formulaire possède l’attribut name="submit". La condition isset($_POST['submit']) permet de vérifier si le formulaire a bien été envoyé avant de lancer tout traitement.
Vérifier si une variable existe en PHP ?
<?php
$erreurs = [];
if (isset($_POST['submit'])) {
if (!isset($_POST['nom']) || $_POST['nom'] === '') {
$erreurs[] = "Le champ nom est obligatoire.";
}
if (!isset($_POST['email']) || $_POST['email'] === '') {
$erreurs[] = "Le champ email est obligatoire.";
}
if (empty($erreurs)) {
echo "Formulaire valide, on peut traiter les données.";
// Traitement (insertion en base, envoi d'email, etc.)
} else {
foreach ($erreurs as $message) {
echo "<p style='color:red;'>$message</p>";
}
}
}On combine ici isset() avec un contrôle de valeur vide pour s’assurer que les champs existent et contiennent bien quelque chose. Cela évite les notices du type « undefined index ».
Comment protéger l’accès aux tableaux avec isset ?
Les tableaux associatifs sont au cœur de nombreux développements PHP (données utilisateur, réponses d’API, configuration). Il est important de vérifier l’existence des clés avant d’y accéder.
Vérifier une clé dans un tableau associatif
<?php
$user = [
'name' => 'Alice',
// 'age' n'est pas défini
];
// Version naïve (à éviter)
echo $user['age']; // Génère une notice si 'age' n'existe pas
// Version protégée
if (isset($user['age'])) {
echo "Âge de l'utilisateur : " . $user['age'];
} else {
echo "Âge non renseigné.";
}La condition isset($user['age']) permet de savoir si la clé age existe et n’est pas null. Sans cette vérification, un accès direct peut générer une notice et rendre le débogage plus pénible.
Utiliser isset avec un tableau multidimensionnel
<?php
$users = [
1 => [
'name' => 'Alice',
'profile' => [
'email' => 'alice@example.com',
'avatar' => 'alice.png'
]
],
2 => [
'name' => 'Bob',
'profile' => [
'email' => 'bob@example.com'
// 'avatar' manquant
]
]
];
$userId = 2;
// On veut récupérer l'avatar de l'utilisateur 2
if (isset($users[$userId]['profile']['avatar'])) {
$avatar = $users[$userId]['profile']['avatar'];
} else {
$avatar = 'default.png';
}
echo "Avatar utilisé : " . $avatar;Dans cet exemple, isset($users[$userId]['profile']['avatar']) s’assure en une seule fois que l’index de l’utilisateur, la clé profile et la clé avatar existent et ne valent pas null avant d’y accéder. Sinon, on tombe sur une valeur par défaut (default.png).
Comment gérer les sessions et la configuration avec isset()
Pour tout ce qui touche à l’authentification et à la configuration, isset() est également un allié précieux.
Vérifier si un utilisateur est connecté
<?php
session_start();
if (isset($_SESSION['user_id'])) {
echo "Utilisateur connecté, ID : " . $_SESSION['user_id'];
// Contenu réservé aux membres
} else {
echo "Vous n'êtes pas connecté.";
// Lien vers la page de connexion, etc.
}Ici, isset($_SESSION['user_id']) permet de déterminer si l’utilisateur dispose d’une session valide contenant son identifiant. C’est une base simple pour contrôler l’accès à des pages protégées.
Vérifier des options de configuration
<?php
$config = [
'db_host' => 'localhost',
'db_user' => 'root',
// 'db_pass' est éventuellement absent
];
if (isset($config['db_host'], $config['db_user'])) {
echo "Configuration minimale pour la base de données présente.";
// Connexion possible avec les informations disponibles
} else {
echo "Configuration de la base de données incomplète.";
}L’utilisation de isset() sur plusieurs clés à la fois permet de vérifier rapidement que la configuration possède au moins les paramètres indispensables.
Éviter les notices et rendre le code plus propre
isset() est souvent utilisé pour éviter les « undefined variable » ou « undefined index » qui encombrent les logs.
Accéder à des variables potentiellement non définies
<?php
// Imaginons que $debug n'est définie que dans certains contextes
if (isset($debug)) {
var_dump($debug);
} else {
echo "Mode debug inactif.";
}Ce pattern est utile lorsqu’une variable n’est initialisée qu’en fonction d’une configuration ou d’un environnement (développement, production, etc.).
Protéger l’accès aux données d’API ou de sources externes
<?php
$response = [
'status' => 'ok',
// 'data' peut parfois être absent selon la réponse de l’API
];
if (isset($response['data'])) {
// Traitement des données
print_r($response['data']);
} else {
echo "Aucune donnée disponible, vérifier la réponse de l'API.";
}Les structures de données issues d’API étant souvent variables, l’utilisation de isset() permet de rendre le code plus sûr et plus explicite sur ce qu’on attend.
Combiner isset() avec l’opérateur ternaire
Le ternaire est très pratique pour fournir des valeurs par défaut tout en gardant un code concis.
Fournir une valeur par défaut proprement
<?php
$user = [
'name' => 'Alice'
// 'nickname' non défini
];
$nickname = isset($user['nickname']) ? $user['nickname'] : 'Invité';
echo "Pseudo : " . $nickname;Ici, si nickname n’existe pas, la variable $nickname prendra la valeur 'Invité'. Ce pattern est extrêmement courant pour gérer des options facultatives.
Utiliser isset() ou l’opérateur de coalescence (??) en PHP
L’opérateur de coalescence null ?? simplifie des patterns très courants basés sur isset(), mais il ne se comporte pas exactement de la même manière.
<?php
$user = [
'name' => 'Alice',
'nickname' => null
];
// Avec isset()
if (isset($user['nickname'])) {
$nickname = $user['nickname'];
} else {
$nickname = 'Invité';
}
echo $nickname; // Affiche "Invité" car nickname est nullIci, isset($user['nickname']) renvoie false parce que la clé existe mais vaut null, donc on utilise la valeur par défaut 'Invité'.
Comment fonctionne la coalescence ?
L’opérateur ?? retourne la première opérande définie et non null, sinon la suivante. Il combine en une seule opération le test d’existence et la valeur par défaut.
<?php
$user = [
'name' => 'Alice',
'nickname' => null
];
// Équivalent plus concis avec ??
$nickname = $user['nickname'] ?? 'Invité';
echo $nickname; // Affiche "Invité"Ce code est fonctionnellement similaire au pattern classique avec isset() + ternaire :
$nickname = isset($user['nickname']) ? $user['nickname'] : 'Invité';Points clés à retenir
isset()est une fonction, plus verbeuse mais très explicite (et disponible depuis toujours).??est plus concis et lisible pour les valeurs par défaut, surtout enchaînées :$_GET['page'] ?? $_POST['page'] ?? 1;- Les deux reposent sur la même idée : considérer
nullcomme « absence de valeur », mais??est pensé pour ce cas d’usage précis.
Quelle est la différence entre Isset et !empty en PHP ?
isset() et empty() sont souvent utilisés ensemble pour valider des données, mais ils testent des choses différentes. Comprendre leurs comportements respectifs permet d’écrire un code plus prévisible.
<?php
$var1 = ''; // Chaîne vide
$var2 = 0; // Zéro
$var3 = null; // Null
$var4 = false; // Booléen faux
var_dump(isset($var1)); // true
var_dump(isset($var2)); // true
var_dump(isset($var3)); // false
var_dump(isset($var4)); // trueComportement de empty()
empty() teste si une variable est « vide » selon les règles PHP (chaîne vide, 0, false, null, etc.).
<?php
$var1 = ''; // Chaîne vide
$var2 = 0; // Zéro
$var3 = null; // Null
$var4 = false; // Booléen faux
$var5 = 'test'; // Chaîne valide
var_dump(empty($var1)); // true
var_dump(empty($var2)); // true
var_dump(empty($var3)); // true
var_dump(empty($var4)); // true
var_dump(empty($var5)); // falseempty() considère plusieurs valeurs comme « vides » : '', 0, 0.0, '0', null, false, array(), et variables non définies.
Exemple pratique : validation de formulaire
<?php
$_POST['nom'] = ''; // Soumis mais vide
$_POST['age'] = 0; // Soumis mais 0
// Avec isset() seul
if (isset($_POST['nom'])) {
echo "nom existe (mais peut être vide)";
}
// Avec !empty() seul
if (!empty($_POST['nom'])) {
echo "nom existe ET contient quelque chose";
} else {
echo "nom vide ou absent";
}
// Combinaison idéale pour formulaires
if (isset($_POST['nom']) && !empty($_POST['nom'])) {
echo "nom valide et non vide";
}Quand utiliser l’un ou l’autre ?
| Situation | isset() | !empty() | isset() && !empty() |
|---|---|---|---|
| Vérifier existence seule | ✅ | ❌ | ❌ |
| Vérifier contenu non vide | ❌ | ✅ | ✅ |
| Formulaires (champs obligatoires) | ⚠️ | ⚠️ | ✅ |
| Variables de config (optionnelles) | ✅ | ❌ | ❌ |
| Compteurs (0 = valeur valide) | ✅ | ❌ | ❌ |
Règle d’or : utiliser isset() pour vérifier l’existence, !empty() pour vérifier l’existence et le contenu, si une variable contient une valeur alors on peut dire qu’elle existe obligatoirement.
isset() vs defined() en PHP : contexte et portée
isset() et defined() testent l’existence de quelque chose en PHP, mais dans des contextes totalement différents. isset() s’applique aux variables runtime, tandis que defined() concerne les constantes définies au niveau du script.
<?php
$name = 'Alice';
$debug = null;
var_dump(isset($name)); // true (variable définie, non null)
var_dump(isset($debug)); // false (valeur null)
var_dump(isset($age)); // false (variable inexistante)
// Avec tableaux
$user = ['name' => 'Bob'];
var_dump(isset($user['name'])); // true
var_dump(isset($user['age'])); // falseisset() est dynamique : elle teste l’état des variables à l’exécution du script.
Comportement de defined()
defined() vérifie si une constante a été définie (via define() ou const).
<?php
// Définir des constantes
define('APP_NAME', 'MonApp');
const DEBUG_MODE = true;
var_dump(defined('APP_NAME')); // true
var_dump(defined('DEBUG_MODE')); // true
var_dump(defined('DB_HOST')); // false (non définie)
echo APP_NAME; // "MonApp"
echo constant('APP_NAME'); // Alternative pour accès dynamiquedefined() ne fonctionne qu’avec les constantes, jamais avec les variables.
Exemple pratique : configuration d’application
<?php
// Fichier config.php
define('DB_HOST', 'localhost');
define('DEBUG', true);
// Dans l'application
if (defined('DB_HOST')) {
echo "Hôte DB : " . DB_HOST;
} else {
echo "DB_HOST non configuré";
}
if (defined('DEBUG') && DEBUG) {
echo "Mode debug activé";
}
// ERREUR si on mélange les deux
if (isset(DB_HOST)) { // ❌ Ne marche PAS ! DB_HOST n'est pas une variable
// Ceci génère une notice
}Usage typique : defined() dans les fichiers de configuration (config.php), isset() partout ailleurs pour les variables et tableaux.
Tableau récapitulatif des différences entre isset et defined en PHP
| Critère | isset() | defined() |
|---|---|---|
| Cible | Variables, clés de tableaux | Constantes uniquement |
| Test null | Oui (retourne false si null) | Non (les constantes ne peuvent pas être null) |
| Contexte | Runtime (exécution) | Toute la durée de vie du script |
| Exemple typique | isset($_POST['id']) | defined('ENV_PROD') |
| Depuis PHP | Toujours | PHP 4.1.0 |
Aide mémoire : isset() → variables (je set mes variables), defined() → constantes (définies une bonne fois pour toutes).
Bonnes pratiques et erreurs courantes
- Utiliser
isset()pour vérifier l’existence et la non-nullité d’une variable avant accès. - Ne pas confondre
isset()avecempty():empty()considère plusieurs valeurs comme « vides » (0, chaîne vide, etc.). - Sur les tableaux, penser aussi à
array_key_exists()si on veut savoir si une clé existe, même si sa valeur estnull. - Éviter de surcharger le code avec des
isset()partout : cibler les endroits où l’on accède à des données externes ou optionnelles. - Centraliser certaines vérifications dans des fonctions utilitaires (par exemple
getParam($source, $key, $default)qui encapsuleisset()).
Conclusion
La fonction isset() est simple mais essentielle en PHP. Elle intervient dès que tu manipules des variables facultatives, des formulaires, des sessions, des réponses d’API ou des tableaux multidimensionnels. Bien maîtrisée, elle permet de réduire les notices, de sécuriser l’accès aux données et de rendre ton code plus clair pour toi comme pour tes lecteurs.