PHP list() e destrutturazione degli array: [$a, $b] = $arr

[$a, $b] = $array; scompone gli elementi di un array in variabili separate in una riga: $a riceve $array[0], $b riceve $array[1]. list($a, $b) = $array; è la grafia più vecchia della stessa cosa, e ['name' => $name] = $user; lo fa per chiave.

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

Abbinare la destrutturazione a explode() è l'uso classico: dividi una stringa, dai un nome ai pezzi, vai avanti.

Saltare elementi

Lascia vuota una posizione per saltarla. Puoi anche fermarti prima: gli elementi inutilizzati alla fine vengono ignorati.

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

Destrutturare un array associativo per chiave

Con le chiavi, l'ordine nell'array non conta e prendi solo i campi che ti servono. La chiave si scrive prima di =>, la variabile dopo.

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

Gli schemi si annidano allo stesso modo per le liste: [[$x1, $y1], [$x2, $y2]] = $line; legge due punti in una volta. Da PHP 7.3 una variabile in uno schema può anche essere un riferimento, [, &$second] = $counts;, quindi modificare $second modifica l'array.

Un'assegnazione usa o le posizioni o le chiavi, mai entrambe. [$a, 'k' => $b] = $arr; si ferma con Cannot mix keyed and unkeyed array entries in assignments.

Scambiare due variabili

Costruisci un array dei due valori in ordine inverso e destrutturalo. Non serve una variabile temporanea.

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

Restituire più valori da una funzione

Una funzione PHP restituisce un solo valore, ma quel valore può essere un array. Destrutturarlo nel punto della chiamata lo fa sembrare più valori restituiti. Per più di due o tre valori, restituisci delle chiavi così chi chiama non può confondere l'ordine.

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

Destrutturazione in foreach

La stessa sintassi funziona nella riga del foreach, così ogni riga arriva già divisa in variabili con un nome. È ciò che si intende con "foreach con list()". Altri schemi di ciclo sono nella pagina su 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'operatore spread (...)

I tre puntini espandono un array sul posto. In un array letterale, [...$a, ...$b] unisce gli array. In una chiamata di funzione, f(...$args) passa gli elementi come argomenti separati. Nella definizione di una funzione, ...$args raccoglie gli argomenti in più in 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";

Prima di PHP 8.1, espandere un array con chiavi stringa era un errore; ora le chiavi stringa vengono mantenute e quelle numeriche rinumerate, con le stesse regole di array_merge(). I parametri variadici come ...$amounts sono trattati con gli altri tipi di parametro nella pagina sulle funzioni.

Errore comune: meno elementi che variabili

Se l'array è più corto dello schema, le variabili mancanti diventano null e PHP stampa un warning per ciascuna. Succede con input che non controlli, come una riga con dei campi mancanti. Per [$name, $city, $country] = explode(',', 'Grace'); PHP stampa:

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

Decidi cosa deve essere un pezzo mancante e completa l'array prima di destrutturarlo:

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

Per gli schemi con chiavi, unisci prima dei valori di default: ['a' => $a, 'b' => $b] = $input + ['a' => null, 'b' => null];. L'operatore + aggiunge solo le chiavi che $input non ha già.