PHP list() und Array-Destructuring: [$a, $b] = $arr

[$a, $b] = $array; zerlegt die Elemente eines Arrays in einer Zeile in einzelne Variablen: $a bekommt $array[0], $b bekommt $array[1]. list($a, $b) = $array; ist die ältere Schreibweise davon, und ['name' => $name] = $user; macht es über den Schlüssel.

<?php
$point = [3, 7];
[$x, $y] = $point;
echo "x = $x, y = $y\n";

// Same thing with list()
list($x, $y) = $point;
echo "x = $x, y = $y\n";

// Very common with explode()
[$user, $domain] = explode('@', 'ada@example.com');
echo "User: $user, domain: $domain\n";

Destructuring mit explode() zu kombinieren ist der klassische Einsatz: String aufteilen, die Teile benennen, weitermachen.

Elemente überspringen

Lass eine Position leer, um sie zu überspringen. Du kannst auch früh aufhören: Nicht verwendete Elemente am Ende werden ignoriert.

<?php
$row = ['2026-03-14', 'Ada', 'Lovelace', 'admin', 'active'];

[, $first, $last] = $row;            // skip the date, ignore the rest
echo "$first $last\n";

[$date, , , $role] = $row;           // skip two in the middle
echo "$date: $role\n";

// Only the time part of a timestamp string
[, $time] = explode(' ', '2026-03-14 09:30:00');
echo "Time: $time\n";

Ein assoziatives Array über Schlüssel zerlegen

Mit Schlüsseln spielt die Reihenfolge im Array keine Rolle, und du nimmst nur die Felder, die du brauchst. Der Schlüssel steht vor =>, die Variable dahinter.

<?php
$user = ['id' => 7, 'name' => 'Grace', 'email' => 'grace@example.com', 'age' => 45];

['name' => $name, 'email' => $email] = $user;
echo "$name <$email>\n";

// Rename while you extract
['id' => $userId] = $user;
echo "User #$userId\n";

// Keys can be expressions
$field = 'age';
[$field => $value] = $user;
echo "$field: $value\n";

// Nested: reach inside a nested array
$order = ['id' => 5, 'customer' => ['name' => 'Ada', 'country' => 'UK']];
['id' => $id, 'customer' => ['country' => $country]] = $order;
echo "Order $id ships to $country\n";

Muster lassen sich bei Listen genauso verschachteln: [[$x1, $y1], [$x2, $y2]] = $line; liest zwei Punkte auf einmal. Seit PHP 7.3 kann eine Variable in einem Muster auch eine Referenz sein, [, &$second] = $counts;, sodass eine Änderung an $second das Array ändert.

Eine Zuweisung verwendet entweder Positionen oder Schlüssel, nie beides. [$a, 'k' => $b] = $arr; stoppt mit Cannot mix keyed and unkeyed array entries in assignments.

Zwei Variablen tauschen

Bau ein Array aus den beiden Werten in umgekehrter Reihenfolge und zerlege es zurück. Keine Hilfsvariable nötig.

<?php
$a = 'left';
$b = 'right';

[$a, $b] = [$b, $a];
echo "$a $b\n";

// Rotate three values
$x = 1; $y = 2; $z = 3;
[$x, $y, $z] = [$y, $z, $x];
echo "$x $y $z\n";

Mehrere Werte aus einer Funktion zurückgeben

Eine PHP-Funktion gibt einen Wert zurück, aber dieser Wert kann ein Array sein. Destructuring an der Aufrufstelle lässt es wie mehrere Rückgabewerte aussehen. Bei mehr als zwei oder drei Werten gibst du Schlüssel zurück, damit der Aufrufer die Reihenfolge nicht verwechseln kann.

<?php
function minMax(array $numbers): array
{
    return [min($numbers), max($numbers)];
}

[$low, $high] = minMax([4, 9, 1, 7]);
echo "Range: $low to $high\n";

function parseName(string $full): array
{
    $parts = explode(' ', $full, 2);
    return ['first' => $parts[0], 'last' => $parts[1] ?? ''];
}

['last' => $last, 'first' => $first] = parseName('Ada Lovelace');
echo "$last, $first\n";

Destructuring in foreach

Dieselbe Syntax funktioniert in der foreach-Zeile, sodass jede Zeile schon in benannte Variablen zerlegt ankommt. Das ist gemeint, wenn von „foreach mit list()“ die Rede ist. Weitere Schleifenmuster stehen auf der Seite zu foreach.

<?php
$routes = [
    ['GET', '/users', 'listUsers'],
    ['POST', '/users', 'createUser'],
    ['GET', '/users/{id}', 'showUser'],
];

foreach ($routes as [$method, $path, $handler]) {
    printf("%-5s %-12s -> %s()\n", $method, $path, $handler);
}

$people = [
    ['name' => 'Ada', 'city' => 'London'],
    ['name' => 'Linus', 'city' => 'Helsinki'],
];

foreach ($people as ['name' => $name, 'city' => $city]) {
    echo "$name lives in $city\n";
}

Der Spread-Operator (...)

Die drei Punkte entpacken ein Array an Ort und Stelle. In einem Array-Literal führt [...$a, ...$b] Arrays zusammen. In einem Funktionsaufruf übergibt f(...$args) die Elemente als einzelne Argumente. In einer Funktionsdefinition sammelt ...$args zusätzliche Argumente in einem Array.

<?php
$fruits = ['apple', 'pear'];
$veg = ['carrot'];
$all = [...$fruits, ...$veg, 'bread'];
print_r($all);

// String keys too (PHP 8.1): later keys win, like array_merge
$defaults = ['color' => 'blue', 'size' => 'M'];
$custom = ['size' => 'L'];
print_r([...$defaults, ...$custom]);

// Unpack into function arguments
$numbers = [4, 9, 1];
echo max(...$numbers), "\n";

// Collect any number of arguments
function total(float ...$amounts): float
{
    return array_sum($amounts);
}
echo total(1.5, 2.5, 6), "\n";

Vor PHP 8.1 war das Spreaden eines Arrays mit String-Schlüsseln ein Fehler; jetzt bleiben String-Schlüssel erhalten und numerische Schlüssel werden neu nummeriert, nach denselben Regeln wie bei array_merge(). Variadische Parameter wie ...$amounts werden mit den anderen Parameterarten auf der Seite zu Funktionen behandelt.

Typischer Fehler: weniger Elemente als Variablen

Ist das Array kürzer als das Muster, werden die fehlenden Variablen zu null, und PHP gibt für jede eine Warnung aus. Das passiert bei Eingaben, die du nicht kontrollierst, etwa einer Zeile mit fehlenden Feldern. Bei [$name, $city, $country] = explode(',', 'Grace'); gibt PHP aus:

Warning: Undefined array key 1 in /var/www/html/import.php on line 5

Warning: Undefined array key 2 in /var/www/html/import.php on line 5

Entscheide, was ein fehlendes Teil sein soll, und fülle das Array vor dem Destructuring auf:

<?php
$lines = ['Ada,London,UK', 'Linus,Helsinki', 'Grace'];

foreach ($lines as $line) {
    [$name, $city, $country] = array_pad(explode(',', $line), 3, 'unknown');
    echo "$name | $city | $country\n";
}

Bei Mustern mit Schlüsseln führst du vorher Standardwerte zusammen: ['a' => $a, 'b' => $b] = $input + ['a' => null, 'b' => null];. Der Operator + fügt nur Schlüssel hinzu, die $input noch nicht hat.