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 – 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, bleibt die neue Variable leer:
/** Gibt keinen Wert zurück */
$iErgebnis = unset($sName);
/* $iErgebnis ist null */
1.4 unset() als Sprachkonstrukt (keine Funktion)
Theoretisch kannst du unset sogar ohne Klammern verwenden, wenn du nur eine Variable löschen möchtest. In der Praxis sind Klammern Standard und sorgen für Klarheit.
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]);
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.
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 – aber 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
Typische Fallen beim Einsatz von unset():
- Wer einen Rückgabewert erwartet, bekommt keinen.
- Die Annahme, dass der Speicher direkt wieder verfügbar ist, stimmt nicht immer.
- Löschen und auf null setzen werden leicht verwechselt.
- Der Umgang mit Referenzen und Gültigkeitsbereichen kann irreführend sein.
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.
