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

[$a, $b] = $array; takes the elements of an array apart into separate variables in one line: $a gets $array[0], $b gets $array[1]. list($a, $b) = $array; is the older spelling of the same thing, and ['name' => $name] = $user; does it by key.

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

Pairing destructuring with explode() is the classic use: split a string, name the pieces, move on.

Skip elements

Leave a position empty to skip it. You can also stop early: unused elements at the end are ignored.

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

Destructure an associative array by key

With keys, the order in the array does not matter and you take only the fields you need. The key is written before =>, the variable after it.

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

Patterns nest the same way for lists: [[$x1, $y1], [$x2, $y2]] = $line; reads two points at once. Since PHP 7.3 a variable in a pattern can also be a reference, [, &$second] = $counts;, so changing $second changes the array.

One assignment uses either positions or keys, never both. [$a, 'k' => $b] = $arr; stops with Cannot mix keyed and unkeyed array entries in assignments.

Swap two variables

Build an array of the two values in reverse order and destructure it back. No temporary variable needed.

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

Return multiple values from a function

A PHP function returns one value, but that value can be an array. Destructuring at the call site makes it read like several return values. For more than two or three values, return keys so the caller cannot mix up the order.

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

The same syntax works in the foreach line, so each row arrives already split into named variables. This is what people mean by "foreach with list()". More loop patterns are on the foreach page.

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

The spread operator (...)

The three dots unpack an array in place. In an array literal, [...$a, ...$b] merges arrays. In a function call, f(...$args) passes the elements as separate arguments. In a function definition, ...$args collects extra arguments into an 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";

Before PHP 8.1, spreading an array with string keys was an error; now string keys are kept and numeric keys are renumbered, the same rules as array_merge(). Variadic parameters like ...$amounts are covered with the other parameter kinds on the functions page.

Common mistake: fewer elements than variables

If the array is shorter than the pattern, the missing variables become null and PHP prints a warning for each one. This happens with input you do not control, such as a line with missing fields. For [$name, $city, $country] = explode(',', 'Grace'); PHP prints:

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

Decide what a missing piece should be and pad the array before destructuring:

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

For keyed patterns, merge defaults in first: ['a' => $a, 'b' => $b] = $input + ['a' => null, 'b' => null];. The + operator only adds keys that $input does not already have.