PHP foreach-Schleife: Key Value, Index und Referenz

foreach ($array as $value) führt den Block einmal für jedes Element aus, wobei $value das aktuelle Element ist. Um zusätzlich den Schlüssel zu bekommen, schreibst du 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 funktioniert mit jedem Array, egal welche Schlüssel es hat, und du musst nie einen Zähler verwalten oder eine Länge prüfen. Es ist die Schleife, die du in PHP am häufigsten schreiben wirst.

Über Schlüssel und Werte iterieren

In $key => $value wählst du die Namen selbst: $name => $age, $id => $user, $k => $v. Bei einer Liste sind die Schlüssel die Positionen 0, 1, 2. Bei einem assoziativen Array sind es die String-Schlüssel, die du festgelegt hast.

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

Die letzte Schleife zeigt ein Detail, das überrascht: Ein String-Schlüssel, der wie eine ganze Zahl aussieht, etwa "1", wird als Ganzzahl 1 gespeichert. "01" ist keine kanonische Ganzzahl und bleibt deshalb ein String.

Den Index in foreach bekommen

Bei einer Liste ist der Schlüssel der Index, also reicht foreach ($items as $i => $item). Bei einem assoziativen Array gibt es keine numerische Position, also führst du einen Zähler. Um das erste oder letzte Element anders zu behandeln, vergleichst du den Schlüssel mit array_key_first() oder 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" : ", ";
}

Die letzte Schleife gibt zwischen den Namen ein Komma aus, aber nicht nach dem letzten. Für genau diese Aufgabe ist implode(', ', array_keys($scores)) kürzer; die Prüfung mit array_key_last() ist für Fälle, in denen der letzte Durchlauf eine andere Logik braucht, nicht nur ein anderes Trennzeichen.

Array-Werte in foreach ändern (per Referenz)

$value ist eine Kopie. Eine Zuweisung daran ändert nichts im Array. Um das Array zu ändern, iterierst du entweder per Referenz mit &$value oder schreibst über den Schlüssel zurück.

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

Beides funktioniert. Die Version mit Schlüssel hinterlässt nach der Schleife keinen versteckten Zustand, deshalb bevorzugen viele Teams sie. Um ein neues Array zu bauen, statt eines zu ändern, ist array_map() eine weitere Möglichkeit.

Eine verwandte Frage: Was passiert, wenn du während der Schleife Elemente hinzufügst? Ein normales foreach läuft über das Array, wie es beim Start der Schleife war, also erzeugt $prices[] = ... darin keine zusätzlichen Durchläufe. Eine Referenzschleife läuft über das lebende Array und besucht die neuen Elemente.

Die Falle mit unset() bei foreach per Referenz

Nach foreach ($arr as &$v) ist die Variable $v weiterhin eine Referenz auf das letzte Element des Arrays. Wenn du den Namen $v später in einer normalen Schleife wiederverwendest, schreibt jeder Durchlauf in dieses letzte Element. Führe das hier aus und schau dir das letzte Element an:

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

Die zweite Schleife weist $letters[2] nacheinander A, dann B und dann den Wert des letzten Elements selbst zu, und beim letzten Durchlauf enthält dieser Platz schon B. Die Lösung ist eine Zeile: Setze unset($v); direkt nach jedes foreach per Referenz.

break und continue in foreach

break verlässt die Schleife, continue springt zum nächsten Element. Ein übliches Muster ist die Suche: Iteriere, bis du findest, was du brauchst, und dann break, damit der Rest des Arrays nicht mehr geprüft wird.

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

In verschachtelten Schleifen verlässt break 2 die innere Schleife und die äußere darum herum, und continue 2 springt zum nächsten Durchlauf der äußeren Schleife.

Verschachtelte Arrays und foreach mit list()

Datenzeilen sind Arrays in einem Array. Iteriere über die Zeilen und dann über jede Zeile, oder hol die Felder mit Array-Destructuring direkt in der foreach-Zeile heraus: [$a, $b] für Listen, ['key' => $var] für assoziative Zeilen. list($a, $b) ist die ältere Schreibweise von [$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, " ";
}

Die Seite zu Destructuring zeigt mehr zur Syntax [...] =, einschließlich übersprungener Elemente und verschachtelter Muster.

Eine HTML-Liste oder -Tabelle mit foreach bauen

In einem Template hält die Doppelpunkt-Form foreach (...): mit endforeach; die Schleife zwischen Tags lesbar. Dieser Block baut eine Tabelle, und die Spaltenüberschriften sind Links: Klicke im Tab Page auf eine, und dasselbe Skript läuft erneut mit gesetztem $_GET['sort'], sodass die Zeilen in neuer Reihenfolge zurückkommen.

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

Zwei Gewohnheiten aus diesem Block lohnen sich: Der Wert sort aus der URL wird vor der Verwendung mit einer Liste erlaubter Spalten verglichen, und jeder Wert, der ins HTML ausgegeben wird und Nutzertext enthalten könnte, läuft durch htmlspecialchars().

foreach über null, ein leeres Array oder ein Objekt

Ein leeres Array ist kein Problem: Der Rumpf läuft nie. null, ein String oder eine Zahl schon: PHP gibt eine Warnung aus und überspringt die Schleife. Bei $tags = null; foreach ($tags as $tag) wird ausgegeben:

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

Das passiert am häufigsten bei Daten, die manchmal fehlen, etwa einem optionalen Feld in dekodiertem JSON. Fall mit ?? auf ein leeres Array zurück:

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

Das object in dieser Meldung ist ernst gemeint: foreach über ein Objekt besucht seine Eigenschaften, die von der Stelle der Schleife aus sichtbar sind (außerhalb der Klasse die öffentlichen), mit dem Eigenschaftsnamen als Schlüssel. Klassen, die Iterator oder IteratorAggregate implementieren, und Generatoren entscheiden selbst, was ein foreach sieht.

foreach vs for vs array_map

Eine schnelle Entscheidungshilfe: Wenn der Schleifenrumpf nur einen neuen Wert pro Element berechnet, sagt array_map(fn($x) => $x * 2, $a) das in einer Zeile. Wenn er Seiteneffekte hat (ausgeben, speichern, mehrere Dinge auf einmal zählen) oder break braucht, schreib das foreach.