לולאת foreach ב-PHP: מפתח וערך, אינדקס והפניה

foreach ($array as $value) מריצה את הבלוק פעם אחת לכל איבר, כש-$value מכיל את האיבר הנוכחי. כדי לקבל גם את המפתח, כתבו 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 עובדת על כל מערך, יהיו המפתחות שלו אשר יהיו, ואף פעם לא מנהלים מונה או בודקים אורך. זו הלולאה שתכתבו הכי הרבה ב-PHP.

מעבר על מפתחות וערכים

ב-$key => $value, השמות לבחירתכם: $name => $age, $id => $user, $k => $v. ברשימה, המפתחות הם המיקומים 0, 1, 2. במערך אסוציאטיבי, הם מפתחות המחרוזת שהגדרתם.

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

הלולאה האחרונה מראה פרט שמפתיע אנשים: מפתח מחרוזת שנראה כמו מספר שלם, כמו "1", נשמר כמספר השלם 1. "01" אינו מספר שלם בצורה קנונית, ולכן הוא נשאר מחרוזת.

קבלת האינדקס ב-foreach

ברשימה, המפתח הוא האינדקס, ולכן foreach ($items as $i => $item) זה כל מה שצריך. במערך אסוציאטיבי אין מיקום מספרי, אז החזיקו מונה. כדי לטפל אחרת באיבר הראשון או האחרון, השוו את המפתח ל-array_key_first() או ל-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" : ", ";
}

הלולאה האחרונה מדפיסה פסיק בין שמות אבל לא אחרי האחרון. לעבודה המדויקת הזו implode(', ', array_keys($scores)) קצרה יותר; הבדיקה של array_key_last() נועדה למקרים שבהם הסבב האחרון צריך לוגיקה שונה, ולא רק מפריד שונה.

שינוי ערכי מערך ב-foreach (דרך הפניה)

$value הוא עותק. הצבה אליו לא משנה שום דבר במערך. כדי לשנות את המערך, עברו בלולאה דרך הפניה עם &$value, או כתבו בחזרה דרך המפתח.

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

שתי הדרכים עובדות. בגרסת המפתח לא נשאר מצב נסתר אחרי הלולאה, ולכן צוותים רבים מעדיפים אותה. כדי לבנות מערך חדש במקום לשנות קיים, array_map() היא אפשרות נוספת.

שאלה קשורה: מה קורה אם מוסיפים איברים תוך כדי הלולאה? foreach רגילה עוברת על המערך כפי שהיה כשהלולאה התחילה, ולכן $prices[] = ... בתוכה לא יוצר סבבים נוספים. לולאה דרך הפניה עוברת על המערך החי ואכן מבקרת באיברים החדשים.

מלכודת ה-unset() ב-foreach עם הפניה

אחרי foreach ($arr as &$v), המשתנה $v הוא עדיין הפניה לאיבר האחרון של המערך. אם בהמשך משתמשים שוב בשם $v בלולאה רגילה, כל סבב כותב לתוך האיבר האחרון הזה. הריצו את זה והסתכלו על הפריט האחרון:

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

הלולאה השנייה מציבה ב-$letters[2] את A, אחר כך את B, ואז את הערך של האיבר האחרון עצמו, ובסבב האחרון המקום הזה כבר מחזיק B. התיקון הוא שורה אחת: שימו unset($v); מיד אחרי כל foreach עם הפניה.

break ו-continue ב-foreach

break יוצא מהלולאה, continue מדלג לאיבר הבא. דפוס נפוץ הוא חיפוש: עוברים בלולאה עד שמוצאים את מה שצריך, ואז break כדי ששאר המערך לא ייבדק.

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

בלולאות מקוננות, break 2 יוצא מהלולאה הפנימית ומזו שסביבה, ו-continue 2 קופץ לסבב הבא של הלולאה החיצונית.

מערכים מקוננים ו-foreach עם list()

שורות נתונים הן מערכים בתוך מערך. עברו על השורות, ואז על כל שורה, או שלפו את השדות ישירות בשורת ה-foreach עם פירוק מערך: [$a, $b] לרשימות, ['key' => $var] לשורות אסוציאטיביות. list($a, $b) הוא הכתיב הישן של [$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, " ";
}

בעמוד פירוק המערכים יש עוד על התחביר [...] =, כולל דילוג על איברים ותבניות מקוננות.

בניית רשימה או טבלת HTML עם foreach

בתבנית, צורת הנקודתיים foreach (...): עם endforeach; שומרת על הלולאה קריאה בין התגיות. הבלוק הזה בונה טבלה, וכותרות העמודות הן קישורים: לחצו על אחת בלשונית Page ואותו סקריפט ירוץ שוב עם $_GET['sort'] מוגדר, כך שהשורות יחזרו בסדר חדש.

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

שני הרגלים ששווה להעתיק מהבלוק הזה: הערך sort מכתובת ה-URL נבדק מול רשימת עמודות מותרות לפני שמשתמשים בו, וכל ערך שמודפס לתוך HTML ויכול להכיל טקסט של משתמש עובר דרך htmlspecialchars().

foreach על null, על מערך ריק או על אובייקט

מערך ריק זה בסדר: הגוף לא רץ אף פעם. null, מחרוזת או מספר לא: PHP מדפיסה אזהרה ומדלגת על הלולאה. עבור $tags = null; foreach ($tags as $tag) היא מדפיסה:

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

זה קורה הכי הרבה עם נתונים שלפעמים חסרים, כמו שדה אופציונלי ב-JSON מפוענח. עברו למערך ריק עם ??:

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

ה-object בהודעה הזו אמיתי: foreach על אובייקט עוברת על המאפיינים שלו שגלויים מהמקום שבו הלולאה רצה (מחוץ למחלקה, הציבוריים), כששם המאפיין הוא המפתח. מחלקות שמממשות Iterator או IteratorAggregate, וגנרטורים, מחליטים בעצמם מה foreach רואה.

foreach מול for מול array_map

דרך מהירה להחליט: אם גוף הלולאה רק מחשב ערך חדש לכל איבר, array_map(fn($x) => $x * 2, $a) אומרת את זה בשורה אחת. אם יש לו תופעות לוואי (הדפסה, שמירה, ספירה של כמה דברים בבת אחת) או שהוא צריך break, כתבו את ה-foreach.