unset()

Introduzione

La funzione unset() è una funzione built-in di PHP che distrugge una variabile o un elemento di un array. Una volta che una variabile viene eliminata con unset, essa cessa di esistere — farvi riferimento di nuovo si comporta esattamente come se non fosse mai stata dichiarata.

Questa pagina tratta la sintassi di unset(), il suo comportamento con array, riferimenti, proprietà di oggetti e variabili all'interno di funzioni, e come si differenzia dall'assegnare semplicemente null. Conoscere queste distinzioni aiuta a scrivere codice prevedibile ed evitare i problemi più comuni con unset().

Un punto chiave da capire fin da subito: unset() rimuove il nome (il binding della variabile), non necessariamente il valore sottostante. PHP libera la memoria del valore automaticamente tramite il conteggio dei riferimenti e il garbage collector quando niente altro vi punta — non nel momento esatto in cui chiami unset().

Sintassi

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

La funzione accetta una o più variabili (separate da virgole) e non restituisce nulla (void). Ogni argomento è la variabile o l'elemento dell'array che si desidera distruggere.

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

Rimozione di un elemento dell'array

L'uso più comune di unset() è eliminare un elemento da un array tramite la sua chiave:

Esempio di unset() in PHP

Qui rimuoviamo l'elemento all'indice 1 ("banana"). L'output è:

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

Si noti che unset() non reindicizza l'array — le chiavi rimanenti rimangono 0 e 2, lasciando un "buco". Questa è la sorpresa più frequente con unset(). Se si ha bisogno di un elenco pulito e reindicizzato sequenzialmente (0, 1, 2, …), si può passare il risultato attraverso array_values():

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

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

Distruzione di una variabile standalone

Quando chiamata su una variabile semplice, unset() la rimuove completamente. Dopo di ciò, la variabile viene trattata come non definita:

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

L'operatore null coalescing ?? è il modo sicuro per leggere una variabile potenzialmente eliminata, perché non emette un avviso "Undefined variable". Usare isset() è un altro modo comune per verificare se una variabile esiste ancora.

unset() vs. assegnazione di null

Queste due operazioni sembrano simili ma non sono la stessa cosa:

<?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
?>

Usa unset() quando vuoi che la variabile (o la chiave dell'array) non esista. Assegna null quando vuoi mantenere la variabile ma svuotarne il valore. Da notare che isset() restituisce false in entrambi i casi, quindi per distinguerli occorre verificare direttamente l'esistenza della chiave. Vedi is_null() e empty() per controlli correlati.

unset() all'interno di una funzione

Il comportamento di unset() dipende dallo scope della variabile, e questo mette in difficoltà molti sviluppatori:

<?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();
?>

Quando si usa unset() su una variabile passata per riferimento, viene interrotto solo il riferimento locale — la variabile del chiamante rimane intatta:

<?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
?>

Se hai realmente bisogno che una funzione rimuova una variabile dallo scope chiamante, passala come elemento di array per riferimento o usa una global — ma nella maggior parte dei casi ridisegnare il codice per restituire un valore è più pulito. Per ulteriori informazioni sulle regole di scope, vedi Variables Scope.

Eliminazione di proprietà di oggetti

unset() rimuove anche una proprietà da un'istanza di oggetto:

<?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
)

Il problema del riferimento nel foreach

Un bug classico: dopo aver iterato un array con un riferimento (&$value), la variabile di riferimento punta ancora all'ultimo elemento. Riutilizzarla successivamente corrompe silenziosamente l'array. La soluzione è usare unset() sul riferimento subito dopo il ciclo:

<?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
)

Conclusione

unset() distrugge variabili, elementi di array e proprietà di oggetti, rimuovendo il binding in modo che il nome non esista più. Tieni a mente questi punti:

• Rimuove il nome, non necessariamente il valore — la memoria viene liberata dal conteggio dei riferimenti e dal garbage collector di PHP.
• Eliminare un elemento di un array lascia un buco; usa array_values() per reindicizzare.
• Non equivale ad assegnare null; unset() fa sì che la variabile cessi di esistere.
• All'interno delle funzioni rispetta lo scope, e l'eliminazione di un parametro passato per riferimento interrompe solo il binding locale.
• Usa sempre unset() sulla variabile del ciclo dopo un ciclo foreach ... as &$value.

Per saperne di più su come lavorare con i dati su cui opera unset(), esplora PHP Variables e PHP Arrays.

Esercitazione