Ciclo foreach in PHP: chiave e valore, indice e riferimento

foreach ($array as $value) esegue il blocco una volta per ogni elemento, con $value impostato all'elemento corrente. Per avere anche la chiave, scrivi foreach ($array as $key => $value).

<?php
$colors = ['red', 'green', 'blue'];

foreach ($colors as $color) {
    echo $color, "\n";
}

$ages = ['Ada' => 36, 'Linus' => 28, 'Grace' => 45];

foreach ($ages as $name => $age) {
    echo "$name is $age\n";
}

foreach funziona su qualsiasi array, qualunque siano le chiavi, e non devi mai gestire un contatore né controllare una lunghezza. È il ciclo che scriverai più spesso in PHP.

Scorrere chiavi e valori

In $key => $value i nomi li scegli tu: $name => $age, $id => $user, $k => $v. Su una lista le chiavi sono le posizioni 0, 1, 2. Su un array associativo sono le chiavi stringa che hai definito.

<?php
$config = [
    'host' => 'localhost',
    'port' => 8080,
    'debug' => true,
];

foreach ($config as $key => $value) {
    printf("%-6s = %s\n", $key, var_export($value, true));
}

// Only the keys
foreach (array_keys($config) as $key) {
    echo "key: $key\n";
}

// Keys like "1" become integers
$codes = ["1" => 'one', "01" => 'zero one'];
foreach ($codes as $key => $value) {
    echo gettype($key), " key ", var_export($key, true), " => $value\n";
}

L'ultimo ciclo mostra un dettaglio che sorprende: una chiave stringa che sembra un numero intero, come "1", viene memorizzata come l'intero 1. "01" non è un intero in forma canonica, quindi resta una stringa.

Ottenere l'indice in foreach

Su una lista la chiave è l'indice, quindi foreach ($items as $i => $item) è tutto ciò che serve. Su un array associativo non c'è una posizione numerica, quindi tieni un contatore. Per trattare in modo diverso il primo o l'ultimo elemento, confronta la chiave con array_key_first() o array_key_last().

<?php
$steps = ['Preheat', 'Mix', 'Bake'];

foreach ($steps as $i => $step) {
    echo "Step ", $i + 1, ": $step\n";   // index starts at 0
}

$scores = ['Ada' => 91, 'Linus' => 78, 'Grace' => 85];
$position = 1;
foreach ($scores as $name => $score) {
    echo "#$position $name ($score)\n";
    $position++;
}

$last = array_key_last($scores);
foreach ($scores as $name => $score) {
    echo $name, $name === $last ? "\n" : ", ";
}

L'ultimo ciclo stampa una virgola tra i nomi ma non dopo l'ultimo. Per quel compito preciso implode(', ', array_keys($scores)) è più breve; il controllo con array_key_last() serve quando l'ultimo passaggio richiede una logica diversa, non solo un separatore diverso.

Modificare i valori dell'array in foreach (per riferimento)

$value è una copia. Assegnarle un valore non cambia nulla nell'array. Per modificare l'array, scorri per riferimento con &$value oppure riscrivi tramite la chiave.

<?php
$prices = [10, 25, 40];

foreach ($prices as $price) {
    $price = $price * 2;          // changes the copy only
}
echo implode(', ', $prices), "\n";

foreach ($prices as &$price) {
    $price = $price * 2;          // changes the array
}
unset($price);                    // break the reference (see next section)
echo implode(', ', $prices), "\n";

foreach ($prices as $key => $price) {
    $prices[$key] = $price + 1;   // same effect, no reference
}
echo implode(', ', $prices), "\n";

Funzionano entrambi. La versione con la chiave non lascia stato nascosto dopo il ciclo, ed è per questo che molti team la preferiscono. Per costruire un nuovo array invece di modificarne uno, array_map() è un'altra opzione.

Una domanda collegata: cosa succede se aggiungi elementi durante il ciclo? Un foreach normale scorre l'array com'era all'inizio del ciclo, quindi $prices[] = ... al suo interno non crea passaggi in più. Un ciclo per riferimento scorre l'array reale e visita anche i nuovi elementi.

La trappola di unset() con foreach per riferimento

Dopo foreach ($arr as &$v), la variabile $v è ancora un riferimento all'ultimo elemento dell'array. Se poi riusi il nome $v in un ciclo normale, ogni passaggio scrive in quell'ultimo elemento. Eseguilo e guarda l'ultima voce:

<?php
$letters = ['a', 'b', 'c'];

foreach ($letters as &$v) {
    $v = strtoupper($v);
}
// missing: unset($v);

foreach ($letters as $v) {
    // each pass assigns to $v, which is still $letters[2]
}

print_r($letters);   // C was overwritten

$fixed = ['a', 'b', 'c'];
foreach ($fixed as &$v) {
    $v = strtoupper($v);
}
unset($v);           // the fix
foreach ($fixed as $v) {
}
print_r($fixed);

Il secondo ciclo assegna a $letters[2] prima A, poi B, poi il valore dell'ultimo elemento stesso, e all'ultimo passaggio quella posizione contiene già B. La soluzione è una riga: metti unset($v); subito dopo ogni foreach per riferimento.

break e continue in foreach

break esce dal ciclo, continue passa all'elemento successivo. Uno schema comune è la ricerca: scorri finché non trovi ciò che ti serve, poi break così il resto dell'array non viene controllato.

<?php
$orders = [
    ['id' => 101, 'status' => 'paid'],
    ['id' => 102, 'status' => 'cancelled'],
    ['id' => 103, 'status' => 'paid'],
    ['id' => 104, 'status' => 'pending'],
];

foreach ($orders as $order) {
    if ($order['status'] === 'cancelled') {
        continue;               // skip this one
    }
    echo "Order {$order['id']}: {$order['status']}\n";
}

$found = null;
foreach ($orders as $order) {
    if ($order['status'] === 'pending') {
        $found = $order;
        break;                  // stop searching
    }
}
echo "First pending: ", $found['id'] ?? 'none', "\n";

Nei cicli annidati, break 2 esce dal ciclo interno e da quello che lo contiene, e continue 2 passa al passaggio successivo del ciclo esterno.

Array annidati e foreach con list()

Le righe di dati sono array dentro un array. Scorri le righe e poi ogni riga, oppure estrai i campi direttamente nella riga del foreach con la destrutturazione: [$a, $b] per le liste, ['key' => $var] per le righe associative. list($a, $b) è la grafia più vecchia di [$a, $b].

<?php
$users = [
    ['name' => 'Ada', 'langs' => ['PHP', 'Python']],
    ['name' => 'Linus', 'langs' => ['C']],
];

// Nested foreach
foreach ($users as $user) {
    echo $user['name'], ":";
    foreach ($user['langs'] as $lang) {
        echo " $lang";
    }
    echo "\n";
}

// Destructuring associative rows
foreach ($users as ['name' => $name, 'langs' => $langs]) {
    echo "$name knows ", count($langs), " language(s)\n";
}

// Destructuring list rows (list() is the same as [])
$points = [[1, 2], [3, 5], [8, 13]];
foreach ($points as [$x, $y]) {
    echo "($x, $y) ";
}
echo "\n";
foreach ($points as list($x, $y)) {
    echo $x + $y, " ";
}

La pagina sulla destrutturazione approfondisce la sintassi [...] =, compresi gli elementi saltati e gli schemi annidati.

Costruire una lista o una tabella HTML con foreach

In un template, la forma con i due punti foreach (...): con endforeach; mantiene il ciclo leggibile tra i tag. Questo blocco costruisce una tabella, e le intestazioni delle colonne sono link: cliccane una nella scheda Page e lo stesso script viene eseguito di nuovo con $_GET['sort'] impostato, quindi le righe tornano in un nuovo ordine.

<?php
$products = [
    ['name' => 'Keyboard', 'price' => 49.0, 'stock' => 12],
    ['name' => 'Mouse', 'price' => 19.5, 'stock' => 40],
    ['name' => 'Monitor', 'price' => 189.0, 'stock' => 3],
    ['name' => 'Cable', 'price' => 6.25, 'stock' => 0],
];

$sort = $_GET['sort'] ?? 'name';
if (!in_array($sort, ['name', 'price', 'stock'], true)) {
    $sort = 'name';
}
usort($products, fn($a, $b) => $a[$sort] <=> $b[$sort]);

$total = 0;
foreach ($products as $p) {
    $total += $p['price'] * $p['stock'];
}
?>
<style>
    table { border-collapse: collapse; font-family: sans-serif; }
    th, td { border: 1px solid #ccc; padding: 4px 10px; }
    .out { color: #999; }
</style>
<table>
    <tr>
        <?php foreach (['name', 'price', 'stock'] as $col): ?>
            <th><a href="?sort=<?= $col ?>"><?= ucfirst($col) ?></a><?= $col === $sort ? ' ▲' : '' ?></th>
        <?php endforeach; ?>
    </tr>
    <?php foreach ($products as $p): ?>
        <tr class="<?= $p['stock'] === 0 ? 'out' : '' ?>">
            <td><?= htmlspecialchars($p['name']) ?></td>
            <td><?= number_format($p['price'], 2) ?></td>
            <td><?= $p['stock'] ?></td>
        </tr>
    <?php endforeach; ?>
</table>
<p>Stock value: <?= number_format($total, 2) ?></p>

Due abitudini da copiare da questo blocco: il valore sort preso dall'URL viene confrontato con un elenco di colonne consentite prima di essere usato, e ogni valore stampato nell'HTML che potrebbe contenere testo dell'utente passa per htmlspecialchars().

foreach su null, un array vuoto o un oggetto

Un array vuoto va bene: il corpo non viene mai eseguito. null, una stringa o un numero no: PHP stampa un warning e salta il ciclo. Per $tags = null; foreach ($tags as $tag) stampa:

Warning: foreach() argument must be of type array|object, null given in /var/www/html/index.php on line 4

Succede soprattutto con dati che a volte mancano, come un campo facoltativo in un JSON decodificato. Ripiega su un array vuoto con ??:

foreach ($data['tags'] ?? [] as $tag) {
    echo $tag;
}

L'object in quel messaggio è reale: foreach su un oggetto visita le sue proprietà visibili dal punto in cui gira il ciclo (fuori dalla classe, quelle pubbliche), con il nome della proprietà come chiave. Le classi che implementano Iterator o IteratorAggregate, e i generatori, decidono da sé cosa vede un foreach.

foreach vs for vs array_map

Un modo rapido per decidere: se il corpo del ciclo calcola solo un nuovo valore per elemento, array_map(fn($x) => $x * 2, $a) lo dice in una riga. Se ha effetti collaterali (stampare, salvare, contare più cose insieme) o richiede break, scrivi il foreach.