PHP'foreach' 如何实际工作？

让我通过说我知道foreach是什么，做什么以及如何使用它来加上前缀。这个问题涉及它如何在发动机罩下工作，我不希望任何答案都是 “这就是你如何用foreach循环一个阵列”。

很长一段时间，我认为foreach使用阵列本身。然后我发现许多引用它与数组的副本一起工作的事实，我已经假设这是故事的结尾。但是我最近讨论了这个问题，经过一些实验后发现这实际上并非 100％正确。

让我说明我的意思。对于以下测试用例，我们将使用以下数组：

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

测试案例 1 ：

foreach ($array as $item) {
  echo "$item\n";
  $array[] = $item;
}
print_r($array);

/* Output in loop:    1 2 3 4 5
   $array after loop: 1 2 3 4 5 1 2 3 4 5 */

这清楚地表明我们不直接使用源数组 - 否则循环将永远继续，因为我们在循环期间不断将项目推送到数组。但只是为了确保这种情况：

测试案例 2 ：

foreach ($array as $key => $item) {
  $array[$key + 1] = $item + 2;
  echo "$item\n";
}

print_r($array);

/* Output in loop:    1 2 3 4 5
   $array after loop: 1 3 4 5 6 7 */

这支持了我们的初步结论，我们在循环期间使用源数组的副本，否则我们将在循环期间看到修改后的值。 但...

如果我们查看手册，我们会发现以下声明：

当 foreach 首次开始执行时，内部数组指针会自动重置为数组的第一个元素。

对...... 这似乎表明foreach依赖于源数组的数组指针。但是我们刚刚证明我们没有使用源数组 ，对吧？好吧，不完全是。

测试案例 3 ：

// Move the array pointer on one to make sure it doesn't affect the loop
var_dump(each($array));

foreach ($array as $item) {
  echo "$item\n";
}

var_dump(each($array));

/* Output
  array(4) {
    [1]=>
    int(1)
    ["value"]=>
    int(1)
    [0]=>
    int(0)
    ["key"]=>
    int(0)
  }
  1
  2
  3
  4
  5
  bool(false)
*/

因此，尽管我们不直接使用源数组，但我们直接使用源数组指针 - 指针位于循环结束时数组末尾的事实显示了这一点。除非这不是真的 - 如果是，那么测试用例 1将永远循环。

PHP 手册还指出：

由于 foreach 依赖于内部数组指针，因此在循环内更改它可能会导致意外行为。

那么，让我们找出那个 “意外行为” 是什么（从技术上讲，任何行为都是意料之外的，因为我不再知道会发生什么）。

测试案例 4 ：

foreach ($array as $key => $item) {
  echo "$item\n";
  each($array);
}

/* Output: 1 2 3 4 5 */

测试案例 5 ：

foreach ($array as $key => $item) {
  echo "$item\n";
  reset($array);
}

/* Output: 1 2 3 4 5 */

...... 没有任何出乎意料的事实，它实际上似乎支持 “源头” 理论。

问题

这里发生了什么？我的 C-fu 不足以让我能够通过查看 PHP 源代码来提取正确的结论，如果有人能为我翻译成英文，我将不胜感激。

在我看来， foreach使用数组的副本，但在循环之后将源数组的数组指针设置为数组的末尾。

这是正确的和整个故事吗？
如果没有，它到底在做什么？
是否有任何情况下使用调整数组指针的函数（ each() ， reset()等）在foreach期间可能会影响循环的结果？

答案

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();
    /* ... */
}

对于内部类，通过使用基本上只镜像 C 级别的Iterator接口的内部 API 来避免实际的方法调用。

数组和普通对象的迭代要复杂得多。首先，应该注意的是，PHP 中的 “数组” 实际上是有序的字典，它们将按照这个顺序遍历（只要你没有使用类似sort东西，就会匹配插入顺序）。这与通过键的自然顺序（其他语言中的列表通常如何工作）或根本没有定义的顺序（其他语言中的字典如何工作）相反。

这同样适用于对象，因为对象属性可以看作是将属性名称映射到其值的另一个（有序）字典，以及一些可见性处理。在大多数情况下，对象属性实际上并不是以这种相当低效的方式存储的。但是，如果您开始迭代对象，则通常使用的压缩表示将转换为实际字典。那时，普通对象的迭代变得非常类似于数组的迭代（这就是为什么我不在这里讨论普通对象迭代）。

到现在为止还挺好。迭代字典不能太难，对吧？当您意识到在迭代期间数组 / 对象可以更改时，问题就开始了。有多种方法可以实现：

如果使用foreach ($arr as &$v)通过引用进行迭代，则$arr将变为引用，您可以在迭代期间更改它。
在 PHP 5 中，即使您按值迭代也适用，但数组之前是一个引用： $ref =& $arr; foreach ($ref as $v)
对象具有通过处理传递语义，这必须实际意味着它们的行为类似于引用。因此，在迭代期间总是可以更改对象。

在迭代期间允许修改的问题是删除当前所在元素的情况。假设您使用指针来跟踪您当前所在的数组元素。如果现在释放此元素，则会留下悬空指针（通常会导致段错误）。

有不同的方法来解决这个问题。 PHP 5 和 PHP 7 在这方面有很大不同，我将在下面描述这两种行为。总结是 PHP 5 的方法相当愚蠢并导致各种奇怪的边缘情况问题，而 PHP 7 更复杂的方法导致更可预测和一致的行为。

作为最后的初步，应该注意 PHP 使用引用计数和写时复制来管理内存。这意味着如果您 “复制” 一个值，实际上只是重用旧值并增加其引用计数（refcount）。只有在执行某种修改后，才会执行真正的副本（称为 “复制”）。看到你被骗了就此主题进行更广泛的介绍。

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 执行以下 schenanigans：在循环体执行之前，foreach 会将指向当前元素及其散列的指针备份到 per-foreach HashPointer 。循环体运行后，如果 IAP 仍然存在，IAP 将被设置回该元素。但是，如果元素已被删除，我们将只使用 IAP 当前所在的位置。这个计划大多有点类型，但是你可以从中获得许多奇怪的行为，其中一些我将在下面演示。

数组重复

IAP 是数组的可见特征（通过current的函数族公开），因为 IAP 计数的这些更改是在写时复制语义下的修改。不幸的是，这意味着 foreach 在很多情况下被迫复制它迭代的数组。确切的条件是：

该数组不是引用（is_ref = 0）。如果它是一个引用，那么对它的更改应该传播，因此不应该重复。
该数组的 refcount> 1。如果 refcount 为 1，则不共享该数组，我们可以直接修改它。

如果数组没有重复（is_ref = 0，refcount = 1），那么只有它的引用计数会递增（*）。此外，如果使用 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）不递增引用计数，从而允许迭代数组在循环中任意修改，或 c）根本不使用 IAP（ PHP 7 解决方案）。

职位晋升令

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

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

然而，作为一种相当特殊的雪花， foreach选择做的事情略有不同：

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

也就是说，在循环体运行之前，数组指针已经向前移动。这意味着当循环体正在处理元素$i ，IAP 已经在元素$i+1 。这就是为什么在迭代期间显示修改的代码示例将始终取消设置下一个元素而不是当前元素的原因。

示例：您的测试用例

上面描述的三个方面应该为您提供对 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将再次在单独的阵列上工作。

示例： `current`在 foreach 中的影响

显示各种复制行为的一种好方法是观察 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 将是不同的。你得到2而不是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推进指针的方式，你仍然可以看到一个一个一个的行为。

在进行 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的引用数是 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

Hashtable 迭代器

如果您还记得，数组迭代的主要问题是如何处理迭代中的元素删除。为了这个目的，PHP 5 使用了单个内部数组指针（IAP），这有点不是最理想的，因为必须拉伸一个数组指针以支持多个同时的 foreach 循环以及与reset()等的交互。

PHP 7 使用不同的方法，即它支持创建任意数量的外部，安全的哈希表迭代器。这些迭代器必须在数组中注册，从那时起它们具有与 IAP 相同的语义：如果删除了一个数组元素，则指向该元素的所有哈希表迭代器将被提前到下一个元素。

这意味着将的 foreach 不再使用 IAP 的。 foreach 循环对current()等的结果绝对没有影响，并且它自己的行为永远不会受到reset()等函数的影响。

数组重复

PHP 5 和 PHP 7 之间的另一个重要变化涉及阵列复制。现在不再使用 IAP，在所有情况下，按值数组迭代只会执行引用计数增量（而不是重复数组）。如果在 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 */

这反映了对象的句柄语义（即，即使在按值上下文中它们也像引用一样）。

例子

让我们考虑一些示例，从您的测试用例开始：

测试用例 1 和 2 保留相同的输出：按值数组迭代始终保持对原始元素的处理。（在这种情况下，甚至引用和重复行为在 PHP 5 和 PHP 7 之间完全相同）。
测试用例 3 发生了变化：Foreach 不再使用 IAP，因此each()不受循环的影响。它之前和之后将具有相同的输出。
测试用例 4 和 5 保持不变： each()和reset()将在更改 IAP 之前复制数组，而 foreach 仍然使用原始数组。（即使数组已共享，IAP 更改也不重要。）

第二组示例与不同引用 / 引用计数配置下的current()行为有关。这不再有意义，因为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 恢复机制直接跳转到新元素，因为它 “看起来” 像是与 remove 元素相同（由于冲突的哈希和指针）。由于我们不再依赖元素哈希来解决任何问题，因此这不再是一个问题。

在示例 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 之外，数组在循环期间被修改，而这个额外的引用是活的。这会触发一个克隆，并解释这里发生了什么！

这是一篇关于这种写时复制行为的另一个副作用的优秀文章： PHP 三元运算符：快还是不快？

使用foreach()时需要注意的一些要点：

a） foreach适用于原始数组的预期副本 。这意味着 foreach（）将具有 SHARED 数据存储，直到或除非在Notes / User 注释之前未创建prospected copy 。

b）触发预期副本的原因是什么？根据copy-on-write时copy-on-write策略创建预期副本，也就是说，每当传递给 foreach（）的数组发生更改时，都会创建原始数组的克隆。

c）原始数组和 foreach（）迭代器将具有DISTINCT SENTINEL VARIABLES ，即一个用于原始数组，另一个用于 foreach; 请参阅下面的测试代码。 SPL ， Iterators和Array Iterator 。

Stack Overflow 问题如何确保在 PHP 的'foreach' 循环中重置值？解决你问题的案例（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 5

内部数组指针和 HashPointer

数组重复

职位晋升令

示例：您的测试用例

示例： current在 foreach 中的影响

示例：迭代期间的修改

在循环期间替换迭代的实体

PHP 7

Hashtable 迭代器

数组重复

例子

示例： `current`在 foreach 中的影响