Boucle foreach en PHP : clé, valeur, index et référence

foreach ($array as $value) exécute le bloc une fois pour chaque élément, avec $value égal à l'élément courant. Pour obtenir aussi la clé, écrivez 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 fonctionne sur n'importe quel tableau, quelles que soient ses clés, et vous ne gérez jamais de compteur ni de longueur. C'est la boucle que vous écrirez le plus souvent en PHP.

Parcourir les clés et les valeurs

Dans $key => $value, vous choisissez les noms : $name => $age, $id => $user, $k => $v. Sur une liste, les clés sont les positions 0, 1, 2. Sur un tableau associatif, ce sont les clés de type chaîne que vous avez définies.

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

La dernière boucle montre un détail qui surprend : une clé de type chaîne qui ressemble à un entier, comme "1", est stockée comme l'entier 1. "01" n'est pas un entier canonique, donc elle reste une chaîne.

Obtenir l'index dans foreach

Sur une liste, la clé est l'index, donc foreach ($items as $i => $item) suffit. Sur un tableau associatif, il n'y a pas de position numérique, gérez donc un compteur. Pour traiter différemment le premier ou le dernier élément, comparez la clé avec array_key_first() ou 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" : ", ";
}

La dernière boucle affiche une virgule entre les noms mais pas après le dernier. Pour ce travail précis, implode(', ', array_keys($scores)) est plus court ; le test array_key_last() sert quand le dernier passage a besoin d'une logique différente, pas seulement d'un autre séparateur.

Modifier les valeurs d'un tableau dans foreach (par référence)

$value est une copie. Lui affecter une valeur ne change rien dans le tableau. Pour modifier le tableau, bouclez par référence avec &$value, ou écrivez via la clé.

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

Les deux fonctionnent. La version par clé ne laisse aucun état caché après la boucle, c'est pourquoi beaucoup d'équipes la préfèrent. Pour construire un nouveau tableau plutôt que d'en modifier un, array_map() est une autre option.

Question voisine : que se passe-t-il si vous ajoutez des éléments pendant la boucle ? Un foreach simple parcourt le tableau tel qu'il était au début de la boucle, donc $prices[] = ... à l'intérieur ne crée pas de passages supplémentaires. Une boucle par référence parcourt le tableau vivant et visite bien les nouveaux éléments.

Le piège de unset() avec foreach par référence

Après foreach ($arr as &$v), la variable $v reste une référence vers le dernier élément du tableau. Si vous réutilisez ensuite le nom $v dans une boucle normale, chaque passage écrit dans ce dernier élément. Exécutez ceci et regardez le dernier élément :

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

La seconde boucle affecte A, puis B, puis la propre valeur du dernier élément à $letters[2], et au dernier passage cet emplacement contient déjà B. La correction tient en une ligne : placez unset($v); juste après chaque foreach par référence.

break et continue dans foreach

break quitte la boucle, continue passe à l'élément suivant. Un modèle courant est la recherche : bouclez jusqu'à trouver ce qu'il vous faut, puis break pour ne pas vérifier le reste du tableau.

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

Dans des boucles imbriquées, break 2 quitte la boucle intérieure et celle qui l'entoure, et continue 2 passe au passage suivant de la boucle extérieure.

Tableaux imbriqués et foreach avec list()

Des lignes de données sont des tableaux dans un tableau. Parcourez les lignes, puis chaque ligne, ou extrayez directement les champs dans la ligne foreach avec la déstructuration : [$a, $b] pour les listes, ['key' => $var] pour les lignes associatives. list($a, $b) est l'ancienne écriture de [$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 page sur la déstructuration détaille la syntaxe [...] =, y compris les éléments ignorés et les motifs imbriqués.

Construire une liste ou un tableau HTML avec foreach

Dans un template, la forme à deux-points foreach (...): avec endforeach; garde la boucle lisible entre les balises. Ce bloc construit un tableau dont les en-têtes de colonnes sont des liens : cliquez-en un dans l'onglet Page et le même script s'exécute à nouveau avec $_GET['sort'] défini, si bien que les lignes reviennent dans un nouvel ordre.

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

Deux habitudes à reprendre de ce bloc : la valeur sort venant de l'URL est vérifiée par rapport à une liste de colonnes autorisées avant d'être utilisée, et chaque valeur affichée dans du HTML qui pourrait contenir du texte d'utilisateur passe par htmlspecialchars().

foreach sur null, un tableau vide ou un objet

Un tableau vide ne pose aucun problème : le corps ne s'exécute jamais. null, une chaîne ou un nombre, si : PHP affiche un warning et saute la boucle. Pour $tags = null; foreach ($tags as $tag), il affiche :

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

Cela arrive surtout avec des données parfois absentes, comme un champ facultatif dans du JSON décodé. Rabattez-vous sur un tableau vide avec ?? :

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

Le mot object dans ce message est réel : foreach sur un objet visite les propriétés visibles depuis l'endroit où tourne la boucle (hors de la classe, les publiques), avec le nom de la propriété comme clé. Les classes qui implémentent Iterator ou IteratorAggregate, ainsi que les générateurs, décident elles-mêmes de ce que voit un foreach.

foreach, for ou array_map

Une façon rapide de décider : si le corps de la boucle se contente de calculer une nouvelle valeur par élément, array_map(fn($x) => $x * 2, $a) le dit en une ligne. S'il a des effets de bord (afficher, enregistrer, compter plusieurs choses à la fois) ou a besoin de break, écrivez le foreach.