Eine CSV-Zeile kommt als Array mit sechs Feldern an, und darunter stehen sechs Zeilen, die jedes Feld einzeln in eine Variable schreiben. Das ist nicht falsch, nur unnötig lang. PHP kann diese Zuweisung in einer einzigen Zeile erledigen.
Im Bild zerfällt ein Array in einzelne benannte Kacheln, eine Position bleibt bewusst leer. Beide Fälle kommen weiter unten vor.
Was PHP Destructuring bedeutet
PHP Destructuring beschreibt eine Zuweisung, bei der links vom Gleichheitszeichen mehrere Ziele stehen. Weil dabei ausschließlich Arrays zerlegt werden, ist auch der Begriff Array Destructuring gebräuchlich. Die eckigen Klammern links definieren kein Array, sie geben die Struktur vor, nach der das Array auf der rechten Seite verteilt wird.
<?php
$paar = ['Berlin', 3600000];
[$stadt, $einwohner] = $paar;
echo $stadt; /* Berlin */
echo $einwohner; /* 3600000 */
Diese Syntax gibt es seit PHP 7.1. Davor stand dafür das Sprachkonstrukt list() zur Verfügung, das weiterhin funktioniert und nicht abgekündigt ist. Wer PHP destructuring in fremdem Code sieht, findet also beide Formen nebeneinander.
Alle Schreibweisen auf einen Blick, mit den englischen Bezeichnungen aus der Sprachdokumentation, weil sie in Fehlermeldungen und fremdem Code so auftauchen:
<?php
/* array destructuring in php, short syntax since PHP 7.1 */
[$a, $b] = $values; /* assign by position */
['key' => $a] = $values; /* assign from an associative array */
[, $b] = $values; /* skip an element */
[[$a, $b], $c] = $values; /* nested destructure */
[&$a] = $values; /* assign by reference, PHP 7.3 */
/* Each line assigns one or more values to a variabel on the left.
A missing element does not stop the example, it assigns null. */
Die letzte Zeile der Übersicht ist die, die am seltensten in Beispielen auftaucht und trotzdem gebraucht wird: Mit dem kaufmännischen Und wird nicht der Wert kopiert, sondern eine Referenz gesetzt.
PHP Destructuring nach Position
Bei PHP Destructuring nach Position zählt allein die Reihenfolge. Das erste Element landet in der ersten Variablen, das zweite in der zweiten, und fehlt eine Angabe rechts, bleibt die Variable leer.
<?php
$zeile = ['4711', 'Schraube M4', '0.12', 'Stueck'];
[$nummer, $bezeichnung, $preis, $einheit] = $zeile;
echo $bezeichnung . ' kostet ' . $preis . ' Euro pro ' . $einheit;
/* Schraube M4 kostet 0.12 Euro pro Stueck */
Solange es bei drei oder vier Werten bleibt, ist das gut lesbar. Sobald mehr Felder dazukommen, muss man beim Lesen mitzählen, und genau dann lohnt sich der zweite Weg.
PHP Destructuring nach Schlüssel
Seit derselben Version lässt sich auch nach Schlüssel zerlegen. Die Reihenfolge spielt dabei keine Rolle mehr, und im Code steht, was gemeint ist.
<?php
$datensatz = [
'id' => 17,
'vorname' => 'Anna',
'ort' => 'Leipzig',
'plz' => '04103',
];
['vorname' => $vorname, 'ort' => $ort] = $datensatz;
echo $vorname . ' aus ' . $ort; /* Anna aus Leipzig */
Zwei Vorteile stechen hervor. Es lassen sich gezielt einzelne Felder herausgreifen, ohne die übrigen zu erwähnen. Und wenn die Datenquelle später ein Feld hinzufügt oder umsortiert, bleibt der Code unverändert richtig. Bei mehr als drei Werten ist das die bessere Wahl.
Einzelne Elemente überspringen
Nicht jedes Feld wird gebraucht. Statt Platzhaltervariablen anzulegen, lässt sich die Position einfach leer lassen.
<?php
$messung = ['2026-08-30', '08:15', 21.4, 63];
/* Nur Datum und Temperatur, Uhrzeit und Feuchte
werden uebersprungen. */
[$datum, , $temperatur] = $messung;
echo $datum . ': ' . $temperatur . ' Grad';
/* 2026-08-30: 21.4 Grad */
Die Kommas müssen stehen bleiben, denn sie halten die Position. Wer ein Komma zu wenig setzt, verschiebt alles Folgende um eine Stelle, ohne dass PHP das bemerkt.
PHP Destructuring im foreach-Kopf
Der größte Gewinn von PHP Destructuring zeigt sich in Schleifen über Datensätze. Die Zerlegung wandert in den Schleifenkopf, und der Rumpf enthält nur noch die eigentliche Logik.
<?php
$bestellungen = [
['nr' => 'A-1', 'kunde' => 'Meier', 'summe' => 249.90],
['nr' => 'A-2', 'kunde' => 'Schulz', 'summe' => 79.00],
];
foreach ($bestellungen as ['nr' => $nr, 'kunde' => $kunde, 'summe' => $summe]) {
printf('%s: %s zahlt %.2f Euro%s', $nr, $kunde, $summe, PHP_EOL);
}
/* A-1: Meier zahlt 249.90 Euro
A-2: Schulz zahlt 79.00 Euro */
Vorher standen im Rumpf drei Zugriffe der Form $zeile['kunde'], die den Ablauf zerteilt haben. Danach ist auf einen Blick sichtbar, welche Felder die Schleife überhaupt anfasst. Besonders lohnend ist das bei Daten aus einer Datei, die etwa über PHP file() zum zeilenweisen Einlesen in ein Array hereinkommen.
Verschachtelte Arrays zerlegen
Die Struktur links darf so tief werden wie die Daten rechts. Das ist bei Geodaten und bei Antworten von Schnittstellen häufig nützlich.
<?php
$punkt = [[52.5200, 13.4050], 'Berlin'];
[[$breite, $laenge], $name] = $punkt;
echo $name . ' liegt bei ' . $breite . ' / ' . $laenge;
/* Berlin liegt bei 52.52 / 13.405 */
Auch Mischformen sind erlaubt, also eine Zerlegung nach Position, in der ein Element wiederum nach Schlüsseln aufgeteilt wird. Lesbar bleibt das allerdings nur bis etwa zwei Ebenen.
Zwei Variablen ohne Hilfsvariable tauschen
Ein kleiner Nebeneffekt, der in Sortieralgorithmen jede Menge Zeilen spart.
<?php
$a = 'links';
$b = 'rechts';
[$a, $b] = [$b, $a];
echo $a; /* rechts */
echo $b; /* links */
Das funktioniert, weil die rechte Seite vollständig ausgewertet wird, bevor die erste Zuweisung stattfindet. Der Zwischenspeicher existiert also, nur eben unsichtbar. Wer eigene Sortierlogik schreibt, findet in Individuell sortieren mit PHP und usort() die passende Umgebung für diesen Handgriff.
list() und die Kurzform im Vergleich
Beide Formen tun dasselbe, und die Wahl ist meist Geschmackssache. Ein sachlicher Unterschied bleibt trotzdem.
<?php
$werte = ['rot', 'gruen'];
/* Diese beiden Zeilen sind gleichwertig. */
list($erste, $zweite) = $werte;
[$erste, $zweite] = $werte;
/* Schluessel funktionieren in beiden Formen,
die Kurzform wird dabei aber deutlich lesbarer. */
$farbe = ['name' => 'rot', 'hex' => '#ff0000'];
list('hex' => $hex) = $farbe;
['hex' => $hex] = $farbe;
In neuem Code hat sich die Kurzform durchgesetzt, weil sie zur Array-Schreibweise passt. Bestehenden Code deswegen umzuschreiben lohnt nicht, denn list() bleibt Teil der Sprache.
Wenn Elemente fehlen: Warnung statt Absturz
Der häufigste Fehler bei PHP destructuring tritt erst bei bestimmten Datensätzen auf und ist deshalb tückisch.
<?php
$kurz = ['nur', 'zwei'];
[$eins, $zwei, $drei] = $kurz;
/* Warning: Undefined array key 2
$drei ist null, das Skript laeuft weiter. */
/* Sauberer Weg: vorher auffuellen */
[$eins, $zwei, $drei] = array_pad($kurz, 3, null);
/* Oder pruefen, wenn die Laenge eine Bedingung ist */
if (count($kurz) < 3) {
exit('Unvollstaendiger Datensatz.');
}
Seit PHP 8.0 ist das eine Warnung, davor war es ein Hinweis. In beiden Fällen läuft das Skript weiter und arbeitet mit null, was den Fehler oft erst viel später sichtbar macht. Das Unterdrücken der Meldung ist deshalb die schlechteste aller Möglichkeiten.
flowchart TD
A[Array in Variablen zerlegen] --> B{Schluessel oder Position}
B -->|numerisch| C[Kurzform mit Komma]
B -->|assoziativ| D[Schluessel vor Variable]
C --> E{Mehr als drei Werte}
E -->|ja| D
E -->|nein| F[Fertig]
D --> F[Fertig]
Das Diagramm fasst die Entscheidung zusammen, die vor jeder Zerlegung steht. Sie fällt in den meisten Fällen zugunsten der Schlüssel aus.
Was PHP Destructuring nicht kann
Objekte lassen sich nicht zerlegen Die Zerlegung arbeitet ausschließlich mit Arrays. Bei einem Objekt führt der Weg über die Eigenschaften oder über get_object_vars(), das ein Array liefert.
Es gibt keinen Rest-Operator Eine Schreibweise, die zwei Werte herausnimmt und den Rest in einer weiteren Variablen sammelt, kennt PHP nicht. Wer sie braucht, greift zu array_slice().
Keine Standardwerte in der Zuweisung Ein fehlendes Element lässt sich nicht direkt mit einem Ersatzwert belegen. Dafür ist array_pad() oder der Null-Koaleszenz-Operator danach zuständig.
Wer aus JavaScript kommt, vermisst vor allem die letzten beiden Punkte, denn dort gehören Rest-Operator und Standardwerte zur Grundausstattung. Die Idee ist in beiden Sprachen dieselbe, der Funktionsumfang nicht.
Fazit
PHP destructuring ersetzt gleichförmige Zuweisungsblöcke durch eine Zeile, die zugleich die Struktur der Daten zeigt. Nach Position ist es am kürzesten, nach Schlüssel am haltbarsten, und im Schleifenkopf zahlt es sich am stärksten aus. Wer weiß, dass fehlende Elemente nur eine Warnung auslösen und stillschweigend null setzen, baut die einzige echte Stolperfalle von vornherein ab.
