unset()

Introducción

La función unset() es una función integrada de PHP que destruye una variable o un elemento de un array. Una vez que una variable es eliminada con unset, deja de existir — referenciarla de nuevo se comporta exactamente como si nunca hubiera sido declarada.

Esta página cubre la sintaxis de unset(), su comportamiento con arrays, referencias, propiedades de objetos y variables dentro de funciones, y cómo se diferencia de simplemente asignar null. Conocer estas distinciones te ayuda a escribir código predecible y evitar los errores más comunes con unset().

Un punto clave que debes entender desde el principio: unset() elimina el nombre (el enlace de la variable), no necesariamente el valor subyacente. PHP libera la memoria del valor automáticamente mediante el conteo de referencias y su recolector de basura cuando nada más apunta a él — no en el momento exacto en que llamas a unset().

Sintaxis

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

La función acepta una o más variables (separadas por comas) y no devuelve nada (void). Cada argumento es la variable o elemento de array que deseas destruir.

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

Eliminar un elemento de un array

El uso más común de unset() es eliminar un elemento de un array por su clave:

Ejemplo de unset() en PHP

Aquí eliminamos el elemento en el índice 1 ("banana"). La salida es:

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

Observa que unset() no reindexará el array — las claves restantes se mantienen en 0 y 2, dejando un "hueco". Esta es la sorpresa más frecuente con unset(). Si necesitas una lista limpia y reindexada secuencialmente (0, 1, 2, …), pasa el resultado por array_values():

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

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

Destruir una variable independiente

Cuando se llama sobre una variable simple, unset() la elimina por completo. Después de eso, la variable se trata como indefinida:

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

El operador de fusión de null ?? es la forma segura de leer una variable que posiblemente fue eliminada con unset, porque no emite una advertencia de "Variable indefinida". Usar isset() es otra forma común de verificar si una variable todavía existe.

unset() vs. asignar null

Estas dos opciones parecen similares pero no son lo mismo:

<?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() cuando quieras que la variable (o clave de array) no exista. Asigna null cuando quieras mantener la variable pero borrar su valor. Ten en cuenta que isset() devuelve false en ambos casos, así que para distinguirlos debes verificar la existencia de la clave directamente. Consulta is_null() y empty() para verificaciones relacionadas.

unset() dentro de una función

El comportamiento de unset() depende del ámbito de la variable, y esto confunde a muchos desarrolladores:

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

Cuando usas unset() sobre una variable que fue pasada por referencia, solo se rompe la referencia local — la variable del llamador no se ve afectada:

<?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 realmente necesitas que una función elimine una variable del ámbito del llamador, pásala como elemento de un array referenciado o usa una global — pero en la mayoría de los casos, rediseñar para retornar un valor es más limpio. Para más información sobre las reglas de ámbito, consulta Variables Scope.

Eliminar propiedades de objetos

unset() también elimina una propiedad de una instancia de objeto:

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

El error con referencias en foreach

Un error clásico: después de iterar un array con una referencia (&$value), la variable de referencia aún apunta al último elemento. Reutilizarla más tarde corrompe silenciosamente el array. La solución es usar unset() con la referencia justo después del bucle:

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

Conclusión

unset() destruye variables, elementos de arrays y propiedades de objetos, eliminando el enlace para que el nombre deje de existir. Ten en cuenta estos puntos:

• Elimina el nombre, no necesariamente el valor — la memoria es liberada por el conteo de referencias y el recolector de basura de PHP.
• Eliminar un elemento de un array deja un hueco; usa array_values() para reindexar.
• No es lo mismo que asignar null; unset() hace que la variable deje de existir.
• Dentro de las funciones respeta el ámbito, y eliminar con unset un parámetro pasado por referencia solo rompe el enlace local.
• Siempre usa unset() con la variable del bucle después de un ciclo foreach ... as &$value.

Para aprender más sobre cómo trabajar con los datos sobre los que opera unset(), explora PHP Variables y PHP Arrays.

Práctica