unset()

Introduction

La fonction unset() est une fonction PHP intégrée qui détruit une variable ou un élément d'un tableau. Une fois qu'une variable est supprimée avec unset(), elle n'existe plus — y faire référence à nouveau se comporte exactement comme si elle n'avait jamais été déclarée.

Cette page couvre la syntaxe de unset(), son comportement avec les tableaux, les références, les propriétés d'objets et les variables à l'intérieur des fonctions, ainsi que sa différence avec le simple fait d'assigner null. Connaître ces distinctions vous aide à écrire du code prévisible et à éviter les pièges les plus courants avec unset().

Un point clé à comprendre dès le départ : unset() supprime le nom (le lien de la variable), pas nécessairement la valeur sous-jacente. PHP libère la mémoire de la valeur automatiquement via le comptage de références et son ramasse-miettes lorsque rien d'autre n'y pointe — pas au moment exact où vous appelez unset().

Syntaxe

unset(mixed $var, mixed ...$vars): void

La fonction prend une ou plusieurs variables (séparées par des virgules) et ne retourne rien (void). Chaque argument est la variable ou l'élément de tableau que vous souhaitez détruire.

<?php
$a = 1;
$b = 2;
$c = 3;
unset($a, $b, $c); // destroy several variables in one call
?>

Supprimer un élément d'un tableau

L'utilisation la plus courante de unset() est la suppression d'un élément d'un tableau par sa clé :

Exemple de PHP unset()

Ici, nous supprimons l'élément à l'index 1 ("banana"). Le résultat est :

Array
(
    [0] => apple
    [2] => cherry
)

Remarquez que unset() ne réindexe pas le tableau — les clés restantes restent 0 et 2, laissant un « trou ». C'est la surprise la plus fréquente avec unset(). Si vous avez besoin d'une liste propre et réindexée séquentiellement (0, 1, 2, …), passez le résultat par array_values() :

<?php
$array = ["apple", "banana", "cherry"];
unset($array[1]);
$array = array_values($array);
print_r($array);
?>

Array
(
    [0] => apple
    [1] => cherry
)

Détruire une variable autonome

Lorsqu'elle est appelée sur une variable ordinaire, unset() la supprime entièrement. Après cela, la variable est traitée comme indéfinie :

<?php
$name = "John";
unset($name);
echo $name ?? "Variable is unset"; // Outputs: Variable is unset
?>

L'opérateur de fusion nulle ?? est le moyen sûr de lire une variable potentiellement supprimée, car il n'émet pas d'avertissement « Variable indéfinie ». Utiliser isset() est une autre façon courante de vérifier si une variable existe encore.

unset() vs. assigner null

Ces deux approches se ressemblent mais ne sont pas identiques :

<?php
$x = 5;
$y = 5;

unset($x);   // $x no longer exists
$y = null;   // $y still exists, its value is null

var_dump(isset($x)); // bool(false) — the variable is gone
var_dump(isset($y)); // bool(false) — isset() returns false for null too
var_dump(array_key_exists('y', get_defined_vars())); // bool(true) — $y is still defined
?>

Utilisez unset() lorsque vous souhaitez que la variable (ou la clé de tableau) n'existe pas. Assignez null lorsque vous voulez conserver la variable mais effacer sa valeur. Notez que isset() retourne false dans les deux cas, donc pour les distinguer, vous devez vérifier directement l'existence de la clé. Voir is_null() et empty() pour des vérifications connexes.

unset() à l'intérieur d'une fonction

Le comportement de unset() dépend de la portée de la variable, ce qui déconcerte de nombreux développeurs :

<?php
function destroy_local() {
    $value = 10;
    unset($value); // only the local copy is destroyed
    echo $value ?? "local is unset"; // Outputs: local is unset
}
destroy_local();
?>

Lorsque vous utilisez unset() sur une variable passée par référence, seule la référence locale est brisée — la variable de l'appelant reste intacte :

<?php
function destroy_ref(&$ref) {
    unset($ref); // breaks the local binding, not the original
}

$data = "keep me";
destroy_ref($data);
echo $data; // Outputs: keep me
?>

Si vous avez réellement besoin qu'une fonction supprime une variable dans la portée appelante, passez-la en tant qu'élément de tableau référencé ou utilisez un global — mais dans la plupart des cas, repenser le code pour retourner une valeur est plus propre. Pour plus d'informations sur les règles de portée, voir Variables Scope.

Supprimer des propriétés d'objet

unset() supprime également une propriété d'une instance d'objet :

<?php
$user = new stdClass();
$user->name = "Ann";
$user->role = "admin";

unset($user->role);
var_dump(isset($user->role)); // bool(false)
print_r($user);
?>

bool(false)
stdClass Object
(
    [name] => Ann
)

Le piège de la référence dans foreach

Un bug classique : après avoir itéré un tableau avec une référence (&$value), la variable de référence pointe encore vers le dernier élément. La réutiliser plus tard corrompt silencieusement le tableau. La solution est d'utiliser unset() sur la référence juste après la boucle :

<?php
$items = [1, 2, 3];
foreach ($items as &$value) {
    $value *= 2;
}
unset($value); // break the dangling reference — do this every time

print_r($items);
?>

Array
(
    [0] => 2
    [1] => 4
    [2] => 6
)

Conclusion

unset() détruit les variables, les éléments de tableau et les propriétés d'objets, supprimant le lien de nom de sorte que le nom n'existe plus. Gardez ces points à l'esprit :

• Elle supprime le nom, pas nécessairement la valeur — la mémoire est libérée par le comptage de références et le ramasse-miettes de PHP.
• La suppression d'un élément de tableau laisse un trou ; utilisez array_values() pour réindexer.
• Ce n'est pas la même chose qu'assigner null ; unset() fait cesser d'exister la variable.
• À l'intérieur des fonctions, elle respecte la portée, et la suppression d'un paramètre passé par référence ne brise que le lien local.
• Utilisez toujours unset() sur la variable de boucle après une boucle foreach ... as &$value.

Pour en savoir plus sur les données sur lesquelles unset() opère, explorez PHP Variables et PHP Arrays.

Pratique