list() y desestructuración en PHP: [$a, $b] = $arr

[$a, $b] = $array; separa los elementos de un array en variables distintas en una sola línea: $a recibe $array[0] y $b recibe $array[1]. list($a, $b) = $array; es la forma antigua de escribir lo mismo, y ['name' => $name] = $user; lo hace por clave.

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

Combinar la desestructuración con explode() es el uso clásico: divides una cadena, nombras los trozos y sigues.

Saltarse elementos

Deja una posición vacía para saltártela. También puedes parar antes: los elementos sin usar del final se ignoran.

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

Desestructurar un array asociativo por clave

Con claves, el orden en el array no importa y tomas solo los campos que necesitas. La clave se escribe antes de => y la variable después.

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

Los patrones se anidan igual con listas: [[$x1, $y1], [$x2, $y2]] = $line; lee dos puntos a la vez. Desde PHP 7.3 una variable de un patrón también puede ser una referencia, [, &$second] = $counts;, de modo que cambiar $second cambia el array.

Una asignación usa posiciones o claves, nunca las dos. [$a, 'k' => $b] = $arr; se detiene con Cannot mix keyed and unkeyed array entries in assignments.

Intercambiar dos variables

Construye un array con los dos valores en orden inverso y desestructúralo de vuelta. No hace falta ninguna variable temporal.

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

Devolver varios valores desde una función

Una función de PHP devuelve un valor, pero ese valor puede ser un array. Desestructurar donde se llama hace que se lea como si devolviera varios valores. Con más de dos o tres valores, devuelve claves para que quien llama no pueda confundir el orden.

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

Desestructuración en foreach

La misma sintaxis funciona en la línea del foreach, así que cada fila llega ya separada en variables con nombre. A esto se refiere la gente con "foreach con list()". Hay más patrones de bucles en la página de 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";
}

El operador spread (...)

Los tres puntos despliegan un array en el sitio. En un literal de array, [...$a, ...$b] une arrays. En una llamada a función, f(...$args) pasa los elementos como argumentos separados. En la definición de una función, ...$args reúne los argumentos extra en un 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";

Antes de PHP 8.1, desplegar un array con claves de texto era un error; ahora las claves de texto se conservan y las numéricas se renumeran, con las mismas reglas que array_merge(). Los parámetros variádicos como ...$amounts se explican junto con los demás tipos de parámetros en la página de funciones.

Error frecuente: menos elementos que variables

Si el array es más corto que el patrón, las variables que faltan pasan a ser null y PHP imprime un warning por cada una. Esto ocurre con entradas que no controlas, como una línea a la que le faltan campos. Para [$name, $city, $country] = explode(',', 'Grace'); PHP imprime:

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 qué debe ser una pieza que falta y rellena el array antes de desestructurar:

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

Para patrones con claves, mezcla antes los valores por defecto: ['a' => $a, 'b' => $b] = $input + ['a' => null, 'b' => null];. El operador + solo añade las claves que $input todavía no tiene.