foreach支持对三种不同类型的值进行迭代：

• 阵列
• 正常对象
• Traversable对象

在下面，我将尝试精确地解释迭代在不同情况下是如何工作的。到目前为止，最简单的情况是Traversable对象，因为对于这些foreach本质上只是代码的语法糖沿着这些行：

foreach ($it as $k => $v) { /* ... */ }

/* translates to: */

if ($it instanceof IteratorAggregate) {
    $it = $it->getIterator();
}
for ($it->rewind(); $it->valid(); $it->next()) {
    $v = $it->current();
    $k = $it->key();
    /* ... */
}

字符串
对于内部类，通过使用内部API避免了实际的方法调用，该内部API本质上只是在C级别上镜像Iterator接口。
数组和普通对象的迭代要复杂得多。首先，应该注意的是，在PHP中，“数组”实际上是有序的字典，它们将按照这个顺序被遍历。（只要你没有使用像sort这样的东西，它就匹配插入顺序）。（其他语言的列表通常如何工作）或根本没有定义的顺序（其他语言的字典通常如何工作）。
这同样适用于对象，因为对象属性可以被看作是另一个（有序的）字典，将属性名称Map到它们的值，加上一些可见性处理。在大多数情况下，对象属性实际上并不是以这种相当低效的方式存储的。但是，如果你开始迭代对象，通常使用的打包表示将被转换为真实的字典。在这一点上，普通对象的迭代变得非常类似于数组的迭代（这就是为什么我在这里没有过多讨论普通对象迭代）。
到目前为止，一切都很好。迭代字典不会太难，对吧？当你意识到数组/对象在迭代过程中可能会发生变化时，问题就开始了。有多种方式会发生这种情况：

• 如果您使用foreach ($arr as &$v)通过引用进行迭代，那么$arr将变成引用，您可以在迭代过程中更改它。
• 在PHP 5中，即使你是按值进行排序，但数组事先是一个引用，这也同样适用：$ref =& $arr; foreach ($ref as $v)
• 对象具有通过句柄传递的语义，这对于大多数实际的目的来说意味着它们的行为就像引用一样。所以对象总是可以在迭代过程中被改变。

在迭代过程中允许修改的问题是，你当前所在的元素被删除了。假设你使用一个指针来跟踪你当前所在的数组元素。如果这个元素现在被释放了，你就会留下一个悬空指针（通常会导致segfault）。
解决这个问题有不同的方法。PHP 5和PHP 7在这方面有很大的不同，我将在下面描述这两种行为。总结一下，PHP 5的方法相当愚蠢，导致各种奇怪的边缘情况问题，而PHP 7的方法更复杂，导致更可预测和一致的行为。
作为最后一个预备，应该注意PHP使用引用计数和写时复制来管理内存。这意味着如果你“复制”一个值，你实际上只是重用旧值并增加它的引用计数（refcount）。只有当你执行某种修改时，一个真实的复制（称为“复制”）才会完成。参阅You're being lied to了解关于这个主题的更广泛的介绍。

PHP 5

内部数组指针和HashPointer

PHP 5中的数组有一个专用的“内部数组指针”（IAP），它可以正确地支持修改：每当删除一个元素时，都会检查IAP是否指向这个元素。如果指向，则会前进到下一个元素。
虽然foreach确实使用了IAP，但还有一个额外的复杂性：只有一个IAP，但一个数组可以是多个foreach循环的一部分：

// Using by-ref iteration here to make sure that it's really
// the same array in both loops and not a copy
foreach ($arr as &$v1) {
    foreach ($arr as &$v) {
        // ...
    }
}

型
为了支持只有一个内部数组指针的两个并发循环，foreach执行以下技巧：在执行循环体之前，foreach会将指向当前元素的指针及其哈希值备份到per-foreach HashPointer中。在循环体运行之后，如果该元素仍然存在，IAP将被设置回该元素。但是如果该元素已被删除，我们将只使用IAP当前所在的任何位置。这个方案基本上可以工作，但也有很多奇怪的行为，我将在下面演示其中的一些。

数组复制

IAP是数组的一个可见特性（通过current系列函数公开），因为在写时复制语义下，对IAP的更改会被视为修改。不幸的是，这意味着foreach在许多情况下被迫复制它正在迭代的数组。精确的条件是：
1.数组不是一个引用（is_ref=0）。如果它是一个引用，那么对它的更改 * 应该 * 传播，所以它不应该被复制。
1.数组的refcount>1。如果refcount为1，则该数组不是共享的，我们可以直接修改它。

如果数组没有重复（is_ref=0，refcount=1），那么只有它的refcount会递增（*）。另外，如果使用foreach by reference，那么（可能重复的）数组将被转换为引用。
将此代码视为发生重复的示例：

function iterate($arr) {
    foreach ($arr as $v) {}
}

$outerArr = [0, 1, 2, 3, 4];
iterate($outerArr);

型
这里，$arr将被复制，以防止$arr上的IAP更改泄漏到$outerArr。根据上述条件，该阵列不是引用（is_ref=0），用于两个地方（refcount=2）。这个需求是不幸的，是次优实现的产物（这里不需要考虑迭代期间的修改，所以我们一开始就不需要使用IAP）。
（*）在这里递增refcount听起来无害，但违反了写时复制（COW）语义：这意味着我们要修改refcount=2数组的IAP，而COW规定修改只能在refcount=1的值上执行。这种违反会导致用户可见的行为更改（而COW通常是透明的），因为迭代数组上的IAP更改将是可观察的-但仅在数组上的第一个非IAP修改之前。相反，这三个“有效”选项是a）总是重复，b）不递增refcount，从而允许迭代数组在循环中任意修改，或者c）根本不使用IAP（PHP 7解决方案）。

职位晋升顺序

为了正确理解下面的代码示例，你必须注意最后一个实现细节。在伪代码中，循环某些数据结构的“正常”方式看起来像这样：

reset(arr);
while (get_current_data(arr, &data) == SUCCESS) {
    code();
    move_forward(arr);
}

型
然而，foreach，作为一个相当特殊的 snowflake ，选择做的事情略有不同：

reset(arr);
while (get_current_data(arr, &data) == SUCCESS) {
    move_forward(arr);
    code();
}

型
也就是说，数组指针在循环体运行之前就已经向前移动了。这意味着当循环体在元素$i上工作时，IAP已经在元素$i+1上了。这就是为什么在迭代过程中显示修改的代码样本总是unset下一个元素，而不是当前元素的原因。

示例：您的测试用例

上面描述的三个方面应该可以让您对foreach实现的特性有一个大致完整的印象，我们可以继续讨论一些示例。
测试用例的行为在这一点上很容易解释：

• 在测试用例1和2中，$array以refcount=1开始，所以它不会被foreach复制：只有refcount递增。当循环体随后修改数组（此时refcount=2）时，复制将在此时发生。Foreach将继续处理$array的未修改副本。
• 在测试用例3中，数组再次没有重复，因此foreach将修改$array变量的IAP。在迭代结束时，IAP为NULL（意味着迭代已经完成），each通过返回false来表示。
• 在测试用例4和5中，each和reset都是引用函数。$array在传递给它们时有一个refcount=2，因此必须复制它。因此，foreach将再次在单独的数组上工作。

示例：foreach中current的效果

显示各种复制行为的一个好方法是观察foreach循环中current()函数的行为。考虑以下示例：

foreach ($array as $val) {
    var_dump(current($array));
}
/* Output: 2 2 2 2 2 */

型
这里你应该知道current()是一个by-ref函数（实际上：prefer-ref），即使它不修改数组。它必须是为了与所有其他函数（如next）一起使用，这些函数都是by-ref。引用传递意味着数组必须分开，因此$array和foreach-array将是不同的。上面也提到了1：foreach在运行用户代码之前 * 推进数组指针，而不是之后。因此，即使代码位于第一个元素，foreach也已经将指针推进到第二个元素。
现在我们来做一个小小的修改：

$ref = &$array;
foreach ($array as $val) {
    var_dump(current($array));
}
/* Output: 2 3 4 5 false */

型
这里我们有is_ref=1的情况，所以数组没有被复制（就像上面一样）。但是现在它是一个引用，当传递到by-ref current()函数时，数组不再需要复制。因此current()和foreach在同一个数组上工作。但是，由于foreach前进指针的方式，你仍然可以看到off-by-one行为。
在执行by-ref迭代时，您将获得相同的行为：

foreach ($array as &$val) {
    var_dump(current($array));
}
/* Output: 2 3 4 5 false */

型
这里重要的部分是，当通过引用迭代时，foreach将使$array成为is_ref=1，所以基本上你有和上面一样的情况。
另一个小的变化，这次我们将数组分配给另一个变量：

$foo = $array;
foreach ($array as $val) {
    var_dump(current($array));
}
/* Output: 1 1 1 1 1 */

型

在这里，当循环开始时，$array的refcount是2，所以这一次我们实际上必须提前进行复制。因此，$array和foreach使用的数组将从一开始就完全分离。这就是为什么你在循环之前获得IAP的位置（在本例中，它是在第一个位置）。

示例：迭代中修改

在迭代过程中尝试解释修改是foreach所有问题的起源，因此它可以考虑这种情况下的一些示例。
考虑在同一个数组上的这些嵌套循环（其中使用by-ref迭代来确保它确实是同一个）：

foreach ($array as &$v1) {
    foreach ($array as &$v2) {
        if ($v1 == 1 && $v2 == 1) {
            unset($array[1]);
        }
        echo "($v1, $v2)\n";
    }
}

// Output: (1, 1) (1, 3) (1, 4) (1, 5)

型
这里预期的部分是(1, 2)从输出中丢失，因为元素1被删除了。可能意想不到的是外部循环在第一个元素之后停止。为什么？
这背后的原因是上面描述的嵌套循环技巧：在循环体运行之前，当前IAP位置和哈希被备份到HashPointer中。在循环体之后，它将被恢复，但前提是元素仍然存在，否则当前IAP位置（无论它是什么）被使用。在上面的例子中，情况正是如此：外部循环的当前元素已经被移除，所以它将使用内部循环已经标记为已完成的IAP！
HashPointer备份+恢复机制的另一个结果是，通过reset()等对IAP的更改通常不会影响foreach。例如，以下代码的执行就像reset()根本不存在一样：

$array = [1, 2, 3, 4, 5];
foreach ($array as &$value) {
    var_dump($value);
    reset($array);
}
// output: 1, 2, 3, 4, 5

型
原因是，reset()临时修改IAP时，会在循环体之后恢复到当前的foreach元素。要强制reset()对循环产生影响，必须额外删除当前元素，这样备份/恢复机制就会失败：

$array = [1, 2, 3, 4, 5];
$ref =& $array;
foreach ($array as $value) {
    var_dump($value);
    unset($array[1]);
    reset($array);
}
// output: 1, 1, 3, 4, 5

型
但是，这些例子仍然是合理的。如果您还记得HashPointer还原使用指向元素的指针及其哈希来确定它是否仍然存在，那么真实的乐趣就开始了。但是：哈希有冲突，指针可以重用！这意味着，通过仔细选择数组键，我们可以让foreach相信被删除的元素仍然存在，所以它会直接跳转到它。举个例子：

$array = ['EzEz' => 1, 'EzFY' => 2, 'FYEz' => 3];
$ref =& $array;
foreach ($array as $value) {
    unset($array['EzFY']);
    $array['FYFY'] = 4;
    reset($array);
    var_dump($value);
}
// output: 1, 4

型
根据前面的规则，这里我们通常应该期望输出1, 1, 3, 4。发生的情况是，'FYFY'与删除的元素'EzFY'具有相同的哈希值，并且分配器碰巧重用相同的内存位置来存储元素。因此，foreach最终直接跳转到新插入的元素，从而缩短了循环。

在循环中替换迭代的实体

最后一个奇怪的情况，我想提一下，PHP允许你在循环中替换迭代的实体。所以你可以开始迭代一个数组，然后在中途用另一个数组替换它。或者开始迭代一个数组，然后用一个对象替换它：

$arr = [1, 2, 3, 4, 5];
$obj = (object) [6, 7, 8, 9, 10];

$ref =& $arr;
foreach ($ref as $val) {
    echo "$val\n";
    if ($val == 3) {
        $ref = $obj;
    }
}
/* Output: 1 2 3 6 7 8 9 10 */

正如你在本例中所看到的，一旦替换发生，PHP将从一开始就开始迭代另一个实体。

PHP 7

哈希表迭代器

如果你还记得的话，数组迭代的主要问题是如何在迭代中期处理元素的删除。PHP 5为此使用了一个内部数组指针（IAP），这有点不理想，因为一个数组指针必须被拉伸以支持多个同时的foreach循环 * 和 * 与reset()等的交互。
PHP 7使用了不同的方法，也就是说，它支持创建任意数量的外部安全的哈希表迭代器。这些迭代器必须在数组中注册，从这一点开始，它们具有与IAP相同的语义：如果数组元素被删除，所有指向该元素的哈希表迭代器将前进到下一个元素。
这意味着foreach将不再使用IAP *。foreach循环将绝对不会影响current()等的结果，并且其自身的行为永远不会受到reset()等函数的影响。

数组复制

PHP 5和PHP 7之间的另一个重要变化与数组复制有关。如果数组在foreach循环中被修改，此时将发生复制（根据写时复制），并且foreach将继续在旧阵列上工作。
在大多数情况下，这种变化是透明的，除了更好的性能之外没有其他效果。但是，有一种情况下它会导致不同的行为，即数组预先是引用的情况：

$array = [1, 2, 3, 4, 5];
$ref = &$array;
foreach ($array as $val) {
    var_dump($val);
    $array[2] = 0;
}
/* Old output: 1, 2, 0, 4, 5 */
/* New output: 1, 2, 3, 4, 5 */

以前的引用数组的按值迭代是特殊情况。在这种情况下，不会发生重复，因此迭代期间数组的所有修改都将反映在循环中。在PHP 7中，这种特殊情况已经消失：数组的按值迭代将始终在原始元素上工作，而忽略循环期间的任何修改。
当然，这并不适用于按引用迭代。如果你按引用迭代，所有的修改都会被循环反映出来。有趣的是，普通对象的按值迭代也是如此：

$obj = new stdClass;
$obj->foo = 1;
$obj->bar = 2;
foreach ($obj as $val) {
    var_dump($val);
    $obj->bar = 42;
}
/* Old and new output: 1, 42 */

这反映了对象的by-handle语义（即，即使在by-value上下文中，它们也表现得像引用）。

示例

让我们考虑几个例子，从测试用例开始：

• 测试用例1和测试用例2保持相同的输出：按值数组迭代总是在原始元素上工作。（在这种情况下，即使refcounting和复制行为在PHP 5和PHP 7之间也完全相同）。
• 测试用例3的变化：Foreach不再使用IAP，所以each()不受循环的影响。它在循环前后的输出是相同的。
• 测试用例4和5保持不变：each()和reset()将在更改IAP之前复制阵列，而foreach仍然使用原始阵列。（并不是说IAP更改会有影响，即使阵列是共享的。）

第二组例子与current()在不同reference/refcounting配置下的行为有关。这不再有意义，因为current()完全不受循环的影响，因此其返回值始终保持不变。
然而，当我们在迭代过程中考虑修改时，我们会得到一些有趣的变化。我希望你会发现新的行为更明智。第一个例子：

$array = [1, 2, 3, 4, 5];
foreach ($array as &$v1) {
    foreach ($array as &$v2) {
        if ($v1 == 1 && $v2 == 1) {
            unset($array[1]);
        }
        echo "($v1, $v2)\n";
    }
}

// Old output: (1, 1) (1, 3) (1, 4) (1, 5)
// New output: (1, 1) (1, 3) (1, 4) (1, 5)
//             (3, 1) (3, 3) (3, 4) (3, 5)
//             (4, 1) (4, 3) (4, 4) (4, 5)
//             (5, 1) (5, 3) (5, 4) (5, 5)

正如你所看到的，外层循环在第一次迭代后不再中止，原因是两个循环现在都有完全独立的哈希表迭代器，并且两个循环之间不再有任何通过共享IAP的交叉污染。
另一个奇怪的边缘情况是，当你删除和添加碰巧具有相同哈希值的元素时，你会得到奇怪的效果：

$array = ['EzEz' => 1, 'EzFY' => 2, 'FYEz' => 3];
foreach ($array as &$value) {
    unset($array['EzFY']);
    $array['FYFY'] = 4;
    var_dump($value);
}
// Old output: 1, 4
// New output: 1, 3, 4

以前HashPointer恢复机制直接跳转到新元素，因为它“看起来”像是与删除的元素相同（由于哈希和指针冲突）。由于我们不再依赖元素哈希，这不再是一个问题。

在例子3中，你不修改数组。在所有其他例子中，你修改的是内容或内部数组指针。这在PHP数组中很重要，因为赋值运算符的语义。
PHP中数组的赋值操作符更像是一个懒惰的克隆。将一个变量复制到另一个包含数组的变量将克隆数组，这与大多数语言不同。然而，除非需要，否则实际的克隆不会完成。这意味着克隆只会在其中一个变量被修改时发生（写时复制）。
下面是一个例子：

$a = array(1,2,3);
$b = $a;  // This is lazy cloning of $a. For the time
          // being $a and $b point to the same internal
          // data structure.

$a[] = 3; // Here $a changes, which triggers the actual
          // cloning. From now on, $a and $b are two
          // different data structures. The same would
          // happen if there were a change in $b.

字符串
回到你的测试用例，你可以很容易地想象foreach创建了一个引用数组的迭代器。这个引用的工作方式和我的例子中的变量$b完全一样。但是，迭代器沿着引用只在循环过程中存在，然后它们都被丢弃了。现在你可以看到，除了3之外，在所有情况下，数组都在循环过程中被修改了，而这个额外的引用是活的。这会触发一个克隆，这就解释了这里发生的事情！
下面是一篇关于这种写时复制行为的另一个副作用的优秀文章：The PHP Ternary Operator: Fast or not?

使用foreach()时需要注意的几点：
a）foreach在原始阵列的预期副本上工作。这意味着foreach()将具有SHARED数据存储，直到或除非没有创建prospected copyforeach Notes/User comments。
B）什么触发了预期拷贝？预期拷贝是基于copy-on-write的策略创建的，也就是说，每当传递给foreach()的数组发生变化时，就会创建原始数组的克隆。
c）原始数组和foreach()迭代器将有DISTINCT SENTINEL VARIABLES，也就是说，一个用于原始数组，另一个用于foreach;参见下面的测试代码。
堆栈溢出问题 * How to make sure the value is reset in a 'foreach' loop in PHP? * 解决了您的问题的情况（3，4，5）。
下面的例子显示each（）和reset（）不影响foreach()迭代器的SENTINEL变量(for example, the current index variable)。

$array = array(1, 2, 3, 4, 5);

list($key2, $val2) = each($array);
echo "each() Original (outside): $key2 => $val2<br/>";

foreach($array as $key => $val){
    echo "foreach: $key => $val<br/>";

    list($key2,$val2) = each($array);
    echo "each() Original(inside): $key2 => $val2<br/>";

    echo "--------Iteration--------<br/>";
    if ($key == 3){
        echo "Resetting original array pointer<br/>";
        reset($array);
    }
}

list($key2, $val2) = each($array);
echo "each() Original (outside): $key2 => $val2<br/>";

字符串

输出：

each() Original (outside): 0 => 1
foreach: 0 => 1
each() Original(inside): 1 => 2
--------Iteration--------
foreach: 1 => 2
each() Original(inside): 2 => 3
--------Iteration--------
foreach: 2 => 3
each() Original(inside): 3 => 4
--------Iteration--------
foreach: 3 => 4
each() Original(inside): 4 => 5
--------Iteration--------
Resetting original array pointer
foreach: 4 => 5
each() Original(inside): 0=>1
--------Iteration--------
each() Original (outside): 1 => 2

型

PHP 7注意事项

更新这个答案，因为它已经得到了一些普及：这个答案不再适用于PHP 7。正如在“Backward incompatible changes“中解释的那样，在PHP 7中，foreach工作在数组的副本上，所以数组本身的任何更改都不会反映在foreach循环中。更多细节在链接中。

说明（引用自php.net）：

第一种形式循环array_expression给出的数组。在每次迭代中，当前元素的值被赋给$value，内部数组指针前进1（因此在下一次迭代中，您将看到下一个元素）。
因此，在第一个例子中，数组中只有一个元素，当指针移动时，下一个元素不存在，因此在添加新元素后，因为它已经“决定”它作为最后一个元素。
在第二个例子中，你从两个元素开始，foreach循环不是在最后一个元素，所以它在下一次迭代中计算数组，从而意识到数组中有新元素。
我相信这都是文档中解释的On each iteration部分的结果，这可能意味着foreach在调用{}中的代码之前执行所有逻辑。

测试用例

如果你运行这个：

<?
    $array = Array(
        'foo' => 1,
        'bar' => 2
    );
    foreach($array as $k=>&$v) {
        $array['baz']=3;
        echo $v." ";
    }
    print_r($array);
?>

字符串
你会得到这样的输出：
这意味着它接受了修改，并通过了它，因为它被修改“及时”。但如果你这样做：

<?
    $array = Array(
        'foo' => 1,
        'bar' => 2
    );
    foreach($array as $k=>&$v) {
        if ($k=='bar') {
            $array['baz']=3;
        }
        echo $v." ";
    }
    print_r($array);
?>

型
您将获得：
这意味着数组被修改了，但是因为我们修改它的时候foreach已经在数组的最后一个元素，它“决定”不再循环，即使我们添加了新元素，我们添加它“太晚了”，它没有循环通过。
详细的解释可以在How does PHP 'foreach' actually work?上阅读，它解释了这种行为背后的内部机制。

根据PHP手册提供的文档。
在每一次迭代中，当前元素的值被赋给$v，而内部
数组指针前进1（因此在下一次迭代中，您将查看下一个元素）。
就像你的第一个例子：

$array = ['foo'=>1];
foreach($array as $k=>&$v)
{
   $array['bar']=2;
   echo($v);
}

字符串
$array只有一个元素，所以每次执行时，1赋值给$v，它没有任何其他元素来移动指针
但在第二个例子中：

$array = ['foo'=>1, 'bar'=>2];
foreach($array as $k=>&$v)
{
   $array['baz']=3;
   echo($v);
}

型
$array有两个元素，所以现在$array计算零索引并将指针移动1。对于循环的第一次迭代，添加$array['baz']=3;作为通过引用传递。

很好的问题，因为许多开发人员，即使是有经验的开发人员，都对PHP在foreach循环中处理数组的方式感到困惑。在标准的foreach循环中，PHP会复制循环中使用的数组。循环结束后，副本会立即丢弃。这在简单的foreach循环的操作中是透明的。例如：

$set = array("apple", "banana", "coconut");
foreach ( $set AS $item ) {
    echo "{$item}\n";
}

字符串
这将产生：

apple
banana
coconut

型
所以副本被创建了，但开发人员没有注意到，因为原始数组在循环中或循环结束后没有被引用。然而，当你试图修改循环中的项目时，你会发现它们在完成时没有被修改：

$set = array("apple", "banana", "coconut");
foreach ( $set AS $item ) {
    $item = strrev ($item);
}

print_r($set);

型
这将产生：

Array
(
    [0] => apple
    [1] => banana
    [2] => coconut
)

型
与原始版本相比的任何更改都不可能是通知，实际上与原始版本相比没有任何更改，即使您明确地为$item分配了一个值。这是因为您正在操作$item，因为它出现在正在处理的$set的副本中。您可以通过引用抓取$item来覆盖它，如下所示：

$set = array("apple", "banana", "coconut");
foreach ( $set AS &$item ) {
    $item = strrev($item);
}
print_r($set);

型
这将产生：

Array
(
    [0] => elppa
    [1] => ananab
    [2] => tunococ
)

型
因此，很明显，当$item被引用操作时，对$item的更改会对原始$set的成员进行更改。通过引用使用$item也会阻止PHP创建数组副本。为了测试这一点，首先我们将展示一个快速脚本来演示副本：

$set = array("apple", "banana", "coconut");
foreach ( $set AS $item ) {
    $set[] = ucfirst($item);
}
print_r($set);

型
这将产生：

Array
(
    [0] => apple
    [1] => banana
    [2] => coconut
    [3] => Apple
    [4] => Banana
    [5] => Coconut
)

型
正如示例中所示，PHP复制了$set并使用它来循环，但是当$set在循环中使用时，PHP将变量添加到原始数组中，而不是复制的数组中。基本上，PHP只使用复制的数组执行循环和$item的赋值。因此，上面的循环只执行3次，每次它都会在原始$set的末尾添加另一个值，使原始$set有6个元素，但永远不会进入无限循环。
然而，如果我们引用$item，就像我之前提到的那样，会怎么样呢？在上面的测试中添加一个字符：

$set = array("apple", "banana", "coconut");
foreach ( $set AS &$item ) {
    $set[] = ucfirst($item);
}
print_r($set);

型
结果是一个无限循环。请注意，这实际上是一个无限循环，你要么自己杀死脚本，要么等待你的操作系统耗尽内存。我在我的脚本中添加了下面一行，所以PHP会很快耗尽内存，我建议你做同样的事情，如果你要运行这些无限循环测试：

ini_set("memory_limit","1M");

型
所以在前面的无限循环的例子中，我们看到了PHP为什么要创建一个数组的副本来循环的原因。当一个副本被创建并只由循环构造本身的结构使用时，数组在整个循环执行过程中保持静态，所以你永远不会遇到问题。

PHP foreach循环可以与Indexed arrays、Associative arrays和Object public variables一起使用。
在foreach循环中，php做的第一件事是创建一个要迭代的数组副本。PHP然后迭代这个新的数组copy，而不是原来的数组。这在下面的例子中演示：

<?php
$numbers = [1,2,3,4,5,6,7,8,9]; # initial values for our array
echo '<pre>', print_r($numbers, true), '</pre>', '<hr />';
foreach($numbers as $index => $number){
    $numbers[$index] = $number + 1; # this is making changes to the origial array
    echo 'Inside of the array = ', $index, ': ', $number, '<br />'; # showing data from the copied array
}
echo '<hr />', '<pre>', print_r($numbers, true), '</pre>'; # shows the original values (also includes the newly added values).

字符串
除此之外，php还允许使用iterated values as a reference to the original array value。这在下面演示：

<?php
$numbers = [1,2,3,4,5,6,7,8,9];
echo '<pre>', print_r($numbers, true), '</pre>';
foreach($numbers as $index => &$number){
    ++$number; # we are incrementing the original value
    echo 'Inside of the array = ', $index, ': ', $number, '<br />'; # this is showing the original value
}
echo '<hr />';
echo '<pre>', print_r($numbers, true), '</pre>'; # we are again showing the original value

型

注意：original array indexes不允许作为references使用。

来源：http://dwellupper.io/post/47/understanding-php-foreach-loop-with-examples

你的问题可能会从多个Angular 来理解。PHP Foreach是一个循环，它允许你遍历数组类型。正如预期的那样，根据Marketsplash的foreach执行：
1.数组初始化;
1.开始foreach循环;
1.处理每个项目。
正如你提到的，可以使用foreach，在项目上应用&符号或不应用&符号，以实际将迭代链接到原始数组，从而直接更改原始数组-考虑下面的Marketsplash示例：

$scores = array(50, 60, 70, 80);

foreach ($scores as &$score) {
    $score += 10; // Adds 10 to each score
}

// $scores is now array(60, 70, 80, 90)

字符串