Wer in PHP Variablen, Array-Werte oder Objekteigenschaften loswerden will, greift früher oder später zu unset(). Das Sprachkonstrukt hilft dabei, überflüssige Werte direkt aus dem laufenden Code zu tilgen. Das ist praktisch, wenn man den Überblick behalten und Ressourcen im Griff haben möchte.
Mit unset() schaffst du gezielt Platz: Du entfernst Variablen, einzelne Array - Elemente oder Eigenschaften von Objekten. So bleibt der Code übersichtlich und du behältst die Kontrolle über den Speicherverbrauch.
Kurze Definition: Was ist unset()?
Unset ist in PHP kein gewöhnlicher Funktionsaufruf, sondern ein Sprachkonstrukt. Es sorgt dafür, dass eine Variable, ein Array-Element oder eine Objekteigenschaft restlos entfernt wird. Nach dem Unset ist der jeweilige Eintrag für den weiteren Programmablauf nicht mehr verfügbar.
Hauptzweck: Variablen/Elemente entfernen
Mit unset() löschst du gezielt Daten, die du nicht länger brauchst. Das minimiert das Risiko von Fehlern durch versehentliche Weiterverwendung und hält den Speicherbedarf schlank.
Warum sollte man unset() verstehen?
Versteht man unset() und seinen Einfluss auf Speicher und Ablauf, lassen sich Fehler vermeiden und der Code bleibt besser wartbar.
1. Grundlagen von PHP unset()
Um unset() sinnvoll einzusetzen, hilft ein genauer Blick auf das, was wirklich passiert.
1.1 Definition: Was genau passiert beim „Unsetten“?
Rufst du unset() auf eine Variable oder ein Array-Element auf, verschwindet sie komplett aus dem Kontext. PHP behandelt sie anschließend, als hätte sie nie existiert.
1.2 Syntax: unset($var, … $vars)
Unset nimmt beliebig viele Variablen als Parameter, getrennt durch Kommas. Beispiel:
/** Entfernt beide Variablen */
unset($sName, $sAlter);
Du kannst damit auch gezielt Array-Elemente oder Objekteigenschaften adressieren.
1.3 Rückgabewert: unset() gibt keinen Wert zurück
Unset verhält sich nicht wie eine klassische Funktion. Es liefert keinen Rückgabewert. Versuchst du, das Ergebnis zuzuweisen, erzeugt PHP einen Fehler:
/* Achtung: Dieser Aufruf ist ungültig! */
/* $iErgebnis = unset($sName); */
/* PHP meldet: "Can't use language construct */
/* as expression" */
1.4 unset() als Sprachkonstrukt (keine Funktion)
Im Gegensatz zu vielen anderen Sprachkonstrukten wie echo sind bei unset() die Klammern immer Pflicht. PHP erwartet mindestens einen Parameter in Klammern.
2. unset() auf verschiedene Datentypen anwenden
Unset eignet sich für einzelne Variablen, Array-Elemente und Eigenschaften von Objekten. Je nach Kontext kann sich das Verhalten unterscheiden.
2.1 Einzelne Variablen
Das Entfernen einer Variablen ist unkompliziert:
$sText = "Hallo Welt";
unset($sText);
Greifst du später auf die gelöschte Variable zu, wirft PHP eine Notice.
echo $sText;
/* Notice: Undefined variable: $sText */
2.2 Array-Elemente
Mit unset() löschst du gezielt bestimmte Elemente, egal ob nach Schlüssel oder Index.
Unsetting eines Elements nach Schlüssel (assoziativ):
$aBenutzer = [
"id" => 42,
"name" => "Max",
"rolle" => "Admin"
];
unset($aBenutzer["rolle"]);
Unsetting eines Elements nach Index (numerisch):
$aZahlen = [10, 20, 30];
unset($aZahlen[1]);
Achte darauf: Die Indizes werden bei einem numerischen Array nicht automatisch neu sortiert. Beim Durchlaufen per foreach tauchen Lücken auf:
foreach ($aZahlen as $iIndex => $iWert) {
echo "$iIndex: $iWert\n";
}
// Ausgabe: 0: 10 2: 30
Brauchst du fortlaufende Indizes, hilft array_values():
$aNeu = array_values($aZahlen);
Mehrere Array-Elemente lassen sich auch in einem Schritt entfernen:
$aTest = [1, 2, 3, 4, 5];
unset($aTest[0], $aTest[4]);
Vorsicht: unset() innerhalb einer foreach-Schleife
PHP erlaubt es, während einer foreach-Schleife Elemente per unset() zu entfernen. Bei assoziativen Arrays funktioniert das problemlos. Bei numerisch indizierten Arrays entstehen allerdings Lücken in den Indizes:
<?php
$aZahlen = [10, 20, 30, 40, 50];
foreach ($aZahlen as $iKey => $iWert) {
if ($iWert === 30) {
unset($aZahlen[$iKey]);
}
}
print_r($aZahlen);
/* Array ( [0] => 10 [1] => 20 [3] => 40 [4] => 50 )
Index 2 fehlt! */
?>
Wenn du eine lückenlose Indizierung brauchst, verwende anschließend array_values() oder setze gleich auf array_filter() als sicherere Alternative:
<?php
/* Sicherer: array_filter statt unset in Schleife */
$aZahlen = array_filter($aZahlen, fn($iW) => $iW !== 30);
$aZahlen = array_values($aZahlen);
?>
array_splice() als Alternative
Während unset() den Index beibehält und eine Lücke hinterlässt, entfernt array_splice() das Element und nummeriert die Indizes automatisch neu:
<?php
$aTiere = ['Hund', 'Katze', 'Maus', 'Vogel'];
array_splice($aTiere, 1, 1);
print_r($aTiere);
/* Array ( [0] => Hund [1] => Maus [2] => Vogel )
Kein Index-Loch! */
?>
2.3 Objekt-Eigenschaften
Unset kann öffentliche Eigenschaften aus Objekten löschen.
class Auto {
public $sMarke = "VW";
public $sFarbe = "Rot";
}
$oAuto = new Auto();
unset($oAuto->sFarbe);
Geschützte oder private Eigenschaften lassen sich nur innerhalb der Klasse entfernen, nicht von außen.
Magische Methode __unset():
Falls du versuchst, eine nicht öffentliche Eigenschaft per unset() zu entfernen, kannst du innerhalb der Klasse eine Methode __unset() definieren. Sie wird dann automatisch aufgerufen:
class Beispiel {
private $sDaten = "geheim";
public function __unset($sName) {
echo "Entferne '$sName'\n";
if ($sName === "sDaten") {
$this->sDaten = null;
}
}
}
$oObjekt = new Beispiel();
unset($oObjekt->sDaten);
2.4 Mehrere Variablen oder Elemente in einem Aufruf
Du kannst in einem Aufruf beliebig viele Einträge löschen:
unset($sVorname, $sNachname, $aBenutzer["id"]);
3. Verhalten von unset() in verschiedenen Kontexten
Je nach Gültigkeitsbereich wirkt unset() unterschiedlich. Kontext entscheidet.
3.1 Globaler Skopus: Standardverhalten
Im globalen Codebereich entfernt unset() Variablen ohne Umwege:
$sGlobal = "Test";
unset($sGlobal);
3.2 Innerhalb von Funktionen
Auch in Funktionen gilt: unset() löscht lokale Variablen zuverlässig.
function entferneVariable() {
$sLokal = "Wert";
unset($sLokal);
}
Wird eine globale Variable innerhalb einer Funktion unsettet, betrifft das nur die lokale Referenz. Global bleibt sie bestehen:
$sGlob = "Welt";
function testUnset() {
global $sGlob;
unset($sGlob);
}
testUnset();
echo $sGlob;
// Gibt "Welt" aus
Willst du wirklich eine globale Variable aus einer Funktion löschen, verwende das $GLOBALS-Array:
$sGlob = "Beispiel";
function wirklichEntfernen() {
unset($GLOBALS["sGlob"]);
}
wirklichEntfernen();
Variablen, die als Referenz übergeben wurden, überleben ein unset() in der Funktion. Nur die Referenz selbst verschwindet:
function entferneReferenz(&$sVar) {
unset($sVar);
}
$sTest = "Daten";
entferneReferenz($sTest);
// $sTest bleibt erhalten
Statische Variablen in Funktionen werden mit unset() gelöscht und bei erneutem Funktionsaufruf wieder neu initialisiert:
function statischeVar() {
static $iZaehler = 1;
echo $iZaehler . "\n";
unset($iZaehler);
}
statischeVar();
// 1
statischeVar();
// 1
4. Wann und warum unset() verwenden?
Man muss nicht immer unset() einsetzen, doch es gibt klare Situationen, in denen das Sprachkonstrukt wirklich hilft.
4.1 Speicherverwaltung und -optimierung
Große Arrays und Objekte können den Arbeitsspeicher belasten. Mit unset() entfernst du gezielt, was du nicht mehr brauchst. Der freigewordene Speicher steht aber nicht unbedingt sofort wieder zur Verfügung, weil die Garbage Collection (GC) von PHP selbst entscheidet, wann aufgeräumt wird.
Gerade bei längeren Schleifen oder dem Bearbeiten großer Datenmengen kannst du so den Speicherbedarf drücken:
for ($iIndex = 0; $iIndex < 100000; $iIndex++) {
$aDaten[] = str_repeat("x", 1024);
if ($iIndex % 1000 == 0) {
unset($aDaten);
$aDaten = [];
}
}
Beispiel für das Messen des Speicherverbrauchs:
$aGross = range(1, 100000);
echo memory_get_usage() . "\n";
unset($aGross);
echo memory_get_usage() . "\n";
Bei Webanwendungen mit kurzer Laufzeit ist das meist egal. In langen CLI-Skripten kann es aber entscheidend sein.
Wichtig: unset() gibt den Speicher nicht sofort frei. Es entfernt nur die Referenz auf den Wert. Der eigentliche Speicher wird erst vom Garbage Collector freigegeben, wenn keine weiteren Referenzen mehr existieren. Bei Bedarf kannst du mit gc_collect_cycles() einen manuellen Garbage-Collection-Durchlauf auslösen.
Seit PHP 8.0 gibt es mit WeakMap eine elegante Alternative für bestimmte Speicher-Szenarien. Eine WeakMap speichert Daten, die an ein Objekt gebunden sind, und gibt den Speicher automatisch frei, sobald das Objekt nicht mehr referenziert wird. Das erspart manuelles unset() bei Objekt-bezogenen Caches oder Metadaten.
4.1a Session-Daten gezielt aufräumen
Ein häufiger Einsatzort für unset() ist das Bereinigen von Session-Variablen. Wenn ein Benutzer beispielsweise einen Checkout-Prozess abschließt, solltest du temporäre Daten aus der Session entfernen:
<?php
session_start();
/* Nach abgeschlossenem Checkout */
unset(
$_SESSION['warenkorb_temp'],
$_SESSION['gutschein_code'],
$_SESSION['checkout_schritt']
);
/* Komplette Session beenden: */
/* session_destroy(); */
?>
Zum vollständigen Beenden einer Session gibt es session_destroy(). Mit unset() entfernst du dagegen nur einzelne Schlüssel und behältst den Rest der Session bei.
4.2 Bereinigung und logische Flusskontrolle
Indem du Variablen entfernst, vermeidest du versehentliche Weiterverwendung. Das macht den Code aufgeräumt und reduziert Fehlerquellen.
5. unset() im Vergleich: Häufige Verwirrungen
Oft gibt es Unsicherheiten, wie unset() sich von anderen Konstrukten unterscheidet.
5.1 unset($var) vs. $var = null
Beides sorgt dafür, dass die Variable nicht mehr nutzbar ist, allerdings auf unterschiedliche Art:
-
Mit unset() verschwindet die Variable komplett.
-
Mit = null bleibt die Variable als deklariert im Speicher, ist aber leer.
Beispiel:
$sVar = "Test";
unset($sVar);
var_dump(isset($sVar));
// false
$sVar = "Test";
$sVar = null;
var_dump(isset($sVar));
// false
Der Unterschied: Nach unset() kennt PHP die Variable gar nicht mehr. Nach = null existiert sie noch - nur mit dem Wert null.
5.2 unset() vs. isset() und empty()
isset() prüft, ob eine Variable überhaupt gesetzt und nicht null ist. empty() checkt, ob die Variable als „leer“ gilt. unset() entfernt den Wert komplett:
$sVar = "Hallo";
unset($sVar);
var_dump(isset($sVar));
// false
var_dump(empty($sVar));
// true
6. Wichtige Hinweise und Einschränkungen
Nicht alles lässt sich mit unset() erledigen:
- $this lässt sich in Methoden nicht entfernen.
- Beim Entfernen globaler Variablen ohne $GLOBALS entstehen leicht Fehler.
- Mit Referenzen in Funktionen ist Vorsicht geboten, das Verhalten kann unerwartet sein.
7. Häufige Fehler und Tipps zur Vermeidung
Die wichtigsten Stolperfallen im Überblick:
unset() gibt keinen Rückgabewert zurück. Prüfe den Erfolg stattdessen mit isset().- Der Speicher wird nicht sofort freigegeben, sondern erst durch den Garbage Collector (siehe Abschnitt 4.1).
unset($var) entfernt die Variable komplett, während $var = null sie behält. Nutze isset(), um den Unterschied zu erkennen.- Innerhalb von Funktionen wirkt
unset() nur lokal. Globale oder referenzierte Variablen bleiben unberührt (siehe Abschnitt 3). - Beim Löschen von Array-Elementen in Schleifen ist
array_filter() die sicherere Alternative (siehe Abschnitt 2).
8. Fazit
Wer unset() gezielt einsetzt, hält den Code schlank, schützt sich vor unnötigen Fehlerquellen und nutzt Ressourcen effizienter. Das Sprachkonstrukt eignet sich besonders für lange Skripte, speicherintensive Aufgaben und das bewusste Aufräumen von Variablen und Datenstrukturen. Mit etwas Erfahrung lässt sich schnell einschätzen, wann unset() dem eigenen Code tatsächlich nützt - und wann man getrost darauf verzichten kann.
