list() i destrukturyzacja tablic w PHP: [$a, $b] = $arr

[$a, $b] = $array; rozkłada elementy tablicy na osobne zmienne w jednej linii: $a dostaje $array[0], $b dostaje $array[1]. list($a, $b) = $array; to starszy zapis tego samego, a ['name' => $name] = $user; robi to po kluczu.

<?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";

Połączenie destrukturyzacji z explode() to klasyczne zastosowanie: podziel string, nazwij kawałki, idź dalej.

Pomijanie elementów

Zostaw pozycję pustą, aby ją pominąć. Możesz też skończyć wcześniej: nieużyte elementy na końcu są ignorowane.

<?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";

Destrukturyzacja tablicy asocjacyjnej po kluczu

Z kluczami kolejność w tablicy nie ma znaczenia i bierzesz tylko potrzebne pola. Klucz piszesz przed =>, a zmienną po nim.

<?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";

Wzorce zagnieżdżają się tak samo dla list: [[$x1, $y1], [$x2, $y2]] = $line; odczytuje naraz dwa punkty. Od PHP 7.3 zmienna we wzorcu może też być referencją, [, &$second] = $counts;, więc zmiana $second zmienia tablicę.

Jedno przypisanie używa albo pozycji, albo kluczy, nigdy obu naraz. [$a, 'k' => $b] = $arr; kończy się błędem Cannot mix keyed and unkeyed array entries in assignments.

Zamiana wartości dwóch zmiennych

Zbuduj tablicę z dwóch wartości w odwrotnej kolejności i zdestrukturyzuj ją z powrotem. Zmienna tymczasowa nie jest potrzebna.

<?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";

Zwracanie wielu wartości z funkcji

Funkcja w PHP zwraca jedną wartość, ale ta wartość może być tablicą. Destrukturyzacja w miejscu wywołania sprawia, że wygląda to jak kilka wartości zwracanych. Przy więcej niż dwóch lub trzech wartościach zwracaj klucze, żeby wywołujący nie pomylił kolejności.

<?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";

Destrukturyzacja w foreach

Ta sama składnia działa w linii foreach, więc każdy wiersz przychodzi już rozłożony na nazwane zmienne. To właśnie ma się na myśli, mówiąc o „foreach z list()”. Więcej wzorców pętli znajdziesz na stronie o 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";
}

Operator rozpakowania (...)

Trzy kropki rozpakowują tablicę w miejscu. W literale tablicy [...$a, ...$b] łączy tablice. W wywołaniu funkcji f(...$args) przekazuje elementy jako osobne argumenty. W definicji funkcji ...$args zbiera dodatkowe argumenty w tablicę.

<?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";

Przed PHP 8.1 rozpakowanie tablicy z kluczami tekstowymi było błędem; teraz klucze tekstowe są zachowywane, a liczbowe numerowane od nowa, według tych samych zasad co w array_merge(). Parametry wariadyczne, takie jak ...$amounts, opisuje razem z innymi rodzajami parametrów strona o funkcjach.

Częsty błąd: mniej elementów niż zmiennych

Jeśli tablica jest krótsza niż wzorzec, brakujące zmienne stają się null, a PHP wypisuje ostrzeżenie dla każdej z nich. Zdarza się to przy danych, nad którymi nie masz kontroli, na przykład przy linii z brakującymi polami. Dla [$name, $city, $country] = explode(',', 'Grace'); PHP wypisuje:

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

Zdecyduj, czym ma być brakujący kawałek, i uzupełnij tablicę przed destrukturyzacją:

<?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";
}

Dla wzorców z kluczami najpierw dołącz wartości domyślne: ['a' => $a, 'b' => $b] = $input + ['a' => null, 'b' => null];. Operator + dodaje tylko klucze, których $input jeszcze nie ma.