PHP list() et déstructuration : [$a, $b] = $arr

[$a, $b] = $array; répartit les éléments d'un tableau dans des variables séparées en une ligne : $a reçoit $array[0], $b reçoit $array[1]. list($a, $b) = $array; est l'ancienne écriture de la même chose, et ['name' => $name] = $user; le fait par clé.

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

Associer la déstructuration à explode() est l'usage classique : découper une chaîne, nommer les morceaux, passer à la suite.

Ignorer des éléments

Laissez une position vide pour l'ignorer. Vous pouvez aussi vous arrêter avant la fin : les éléments inutilisés en fin de tableau sont ignorés.

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

Déstructurer un tableau associatif par clé

Avec des clés, l'ordre dans le tableau n'a pas d'importance et vous ne prenez que les champs dont vous avez besoin. La clé s'écrit avant =>, la variable aprè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";

Les motifs s'imbriquent de la même façon pour les listes : [[$x1, $y1], [$x2, $y2]] = $line; lit deux points d'un coup. Depuis PHP 7.3, une variable dans un motif peut aussi être une référence, [, &$second] = $counts;, si bien que modifier $second modifie le tableau.

Une affectation utilise soit des positions, soit des clés, jamais les deux. [$a, 'k' => $b] = $arr; s'arrête avec Cannot mix keyed and unkeyed array entries in assignments.

Échanger deux variables

Construisez un tableau des deux valeurs dans l'ordre inverse et déstructurez-le en retour. Aucune variable temporaire nécessaire.

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

Renvoyer plusieurs valeurs depuis une fonction

Une fonction PHP renvoie une seule valeur, mais cette valeur peut être un tableau. La déstructuration à l'appel la fait lire comme plusieurs valeurs de retour. Au-delà de deux ou trois valeurs, renvoyez des clés pour que l'appelant ne puisse pas se tromper d'ordre.

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

Déstructuration dans foreach

La même syntaxe fonctionne dans la ligne foreach, si bien que chaque ligne arrive déjà découpée en variables nommées. C'est ce qu'on appelle « foreach avec list() ». D'autres modèles de boucle sont sur la page 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";
}

L'opérateur de décomposition (...)

Les trois points déballent un tableau sur place. Dans un littéral de tableau, [...$a, ...$b] fusionne des tableaux. Dans un appel de fonction, f(...$args) passe les éléments comme arguments séparés. Dans une définition de fonction, ...$args rassemble les arguments supplémentaires dans un tableau.

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

Avant PHP 8.1, décomposer un tableau à clés de type chaîne était une erreur ; désormais les clés de type chaîne sont gardées et les clés numériques renumérotées, selon les mêmes règles qu'array_merge(). Les paramètres variadiques comme ...$amounts sont présentés avec les autres types de paramètres sur la page des fonctions.

Erreur fréquente : moins d'éléments que de variables

Si le tableau est plus court que le motif, les variables manquantes valent null et PHP affiche un warning pour chacune. Cela arrive avec des entrées que vous ne maîtrisez pas, comme une ligne avec des champs manquants. Pour [$name, $city, $country] = explode(',', 'Grace');, PHP affiche :

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

Décidez de ce que doit valoir un morceau manquant et complétez le tableau avant de le déstructurer :

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

Pour les motifs avec clés, fusionnez d'abord des valeurs par défaut : ['a' => $a, 'b' => $b] = $input + ['a' => null, 'b' => null];. L'opérateur + n'ajoute que les clés que $input n'a pas déjà.