Pętla foreach w PHP: klucz i wartość, indeks, referencja

foreach ($array as $value) wykonuje blok raz dla każdego elementu, a $value ma wartość bieżącego elementu. Aby dostać także klucz, napisz 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 działa na każdej tablicy, niezależnie od kluczy, i nigdy nie musisz obsługiwać licznika ani sprawdzać długości. To pętla, którą w PHP będziesz pisać najczęściej.

Przechodzenie po kluczach i wartościach

W $key => $value nazwy wybierasz sam: $name => $age, $id => $user, $k => $v. W liście kluczami są pozycje 0, 1, 2. W tablicy asocjacyjnej są to klucze tekstowe, które zdefiniowałeś.

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

Ostatnia pętla pokazuje szczegół, który zaskakuje: klucz tekstowy wyglądający jak liczba całkowita, na przykład "1", jest zapisywany jako liczba całkowita 1. "01" nie jest kanoniczną liczbą całkowitą, więc pozostaje stringiem.

Pobieranie indeksu w foreach

W liście kluczem jest indeks, więc wystarczy foreach ($items as $i => $item). W tablicy asocjacyjnej nie ma pozycji liczbowej, więc prowadź licznik. Aby inaczej potraktować pierwszy lub ostatni element, porównaj klucz z array_key_first() albo 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" : ", ";
}

Ostatnia pętla wypisuje przecinek między imionami, ale nie po ostatnim. Do dokładnie tego zadania krótsze jest implode(', ', array_keys($scores)); sprawdzenie array_key_last() przydaje się, gdy ostatni przebieg potrzebuje innej logiki, a nie tylko innego separatora.

Zmiana wartości tablicy w foreach (przez referencję)

$value jest kopią. Przypisanie do niej niczego w tablicy nie zmienia. Aby zmienić tablicę, przechodź przez referencję z &$value albo zapisuj z powrotem przez klucz.

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

Oba sposoby działają. Wersja z kluczem nie zostawia po pętli żadnego ukrytego stanu, dlatego wiele zespołów ją woli. Gdy budujesz nową tablicę zamiast zmieniać istniejącą, inną opcją jest array_map().

Pokrewne pytanie: co się stanie, jeśli dodajesz elementy w trakcie pętli? Zwykłe foreach przechodzi po tablicy w postaci z chwili startu pętli, więc $prices[] = ... w jej wnętrzu nie tworzy dodatkowych przebiegów. Pętla przez referencję przechodzi po bieżącej tablicy i odwiedza też nowe elementy.

Pułapka z unset() przy foreach przez referencję

Po foreach ($arr as &$v) zmienna $v nadal jest referencją do ostatniego elementu tablicy. Jeśli później użyjesz nazwy $v w zwykłej pętli, każdy przebieg zapisuje do tego ostatniego elementu. Uruchom to i spójrz na ostatni element:

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

Druga pętla przypisuje do $letters[2] kolejno A, potem B, a potem własną wartość ostatniego elementu, a przy ostatnim przebiegu to miejsce zawiera już B. Poprawka to jedna linia: wstaw unset($v); zaraz po każdym foreach przez referencję.

break i continue w foreach

break opuszcza pętlę, continue przechodzi do następnego elementu. Częsty wzorzec to wyszukiwanie: przechodź w pętli, aż znajdziesz to, czego potrzebujesz, a potem break, żeby nie sprawdzać reszty tablicy.

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

W pętlach zagnieżdżonych break 2 opuszcza pętlę wewnętrzną i tę, która ją otacza, a continue 2 przeskakuje do następnego przebiegu pętli zewnętrznej.

Tablice zagnieżdżone i foreach z list()

Wiersze danych to tablice w tablicy. Przechodź po wierszach, a potem po każdym wierszu, albo wyciągnij pola bezpośrednio w linii foreach przez destrukturyzację tablicy: [$a, $b] dla list, ['key' => $var] dla wierszy asocjacyjnych. list($a, $b) to starszy zapis [$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, " ";
}

Na stronie o destrukturyzacji znajdziesz więcej o składni [...] =, w tym pomijanie elementów i wzorce zagnieżdżone.

Budowanie listy lub tabeli HTML przez foreach

W szablonie forma z dwukropkiem foreach (...): i endforeach; utrzymuje czytelność pętli między znacznikami. Ten blok buduje tabelę, a nagłówki kolumn są linkami: kliknij jeden w zakładce Page, a ten sam skrypt uruchomi się ponownie z ustawionym $_GET['sort'], więc wiersze wrócą w nowej kolejności.

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

Dwa nawyki warte skopiowania z tego bloku: wartość sort z adresu URL jest sprawdzana z listą dozwolonych kolumn, zanim zostanie użyta, a każda wartość wypisywana do HTML, która może zawierać tekst użytkownika, przechodzi przez htmlspecialchars().

foreach po null, pustej tablicy lub obiekcie

Pusta tablica nie stanowi problemu: treść po prostu się nie wykona. null, string czy liczba już tak: PHP wypisuje ostrzeżenie i pomija pętlę. Dla $tags = null; foreach ($tags as $tag) wypisuje:

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

Zdarza się to najczęściej przy danych, których czasem brakuje, jak opcjonalne pole w zdekodowanym JSON. Podstaw pustą tablicę przez ??:

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

Słowo object w tym komunikacie nie jest przypadkowe: foreach po obiekcie odwiedza jego właściwości widoczne z miejsca, w którym działa pętla (poza klasą: publiczne), a kluczem jest nazwa właściwości. Klasy implementujące Iterator lub IteratorAggregate oraz generatory same decydują, co widzi foreach.

foreach vs for vs array_map

Szybki sposób na decyzję: jeśli treść pętli tylko oblicza nową wartość dla każdego elementu, array_map(fn($x) => $x * 2, $a) mówi to w jednej linii. Jeśli ma efekty uboczne (wypisywanie, zapisywanie, liczenie kilku rzeczy naraz) albo potrzebuje break, napisz foreach.