10

我有几个关于在 foreach() 循环期间修改数组的查询。在下面的代码中，我遍历三个包含闭包/回调的数组并调用每个数组。在迭代过程中，我在每个数组的末尾附加了一个闭包，但是有时 foreach() 似乎没有识别出数组已经改变了大小，因此附加的闭包不会被调用。

class Foo
{
    private $a1 = array();
    private $a2 = array();

    public function f()
    {
        echo '<pre style="font-size: 20px;">';
        echo 'PHP: ' . phpversion() . '<br><br>';

        $this->a1[] = function() { echo 'a1 '; };
        $this->a1[] = array($this, 'g');
        foreach ($this->a1 as &$v)
        {
            // The callback added in g() never gets called.
            call_user_func($v);
            //echo 'count(v) = ' . count($v) . ' ';
        }

        echo '<br>';

        // The same thing works fine with a for() loop.
        $this->a2[] = function() { echo 'a2 '; };
        $this->a2[] = array($this, 'h');
        for ($i = 0; $i < count($this->a2); ++$i)
            call_user_func($this->a2[$i]);

        echo '<br>';

        // It also works fine using a local array as long as it
        // starts off with more than one element.
        $a3[] = function() { echo 'a3 '; };
        //$a3[] = function() { echo 'a3 '; };
        $i = 0;
        foreach ($a3 as &$x)
        {
            call_user_func($x);
            if ($i++ > 1) // prevent infinite loop
                break;

            // Why does this get called only if $a3 originally starts
            // with more than one element?
            $a3[] = function() { echo 'callback '; };
        }

        echo '</pre>';
    }

    private function g()
    {
        echo 'g() ';
        $this->a1[] = function() { echo 'callback '; };
    }

    private function h()
    {
        echo 'h() ';
        $this->a2[] = function() { echo 'callback '; };
    }
}

$foo = new Foo;
$foo->f();

输出：

PHP: 5.3.14-1~dotdeb.0

a1 g() 
a2 h() callback 
a3

预期输出：

a1 g() callback
a2 h() callback 
a3 callback

$a3如果我在循环之前取消注释第二个元素，则输出：

a3 a3 callback
  1. 为什么第一个循环没有foreach ($this->a1 as &$v)意识到$v有另一个元素要迭代？
  2. 为什么$a3在第三个循环期间修改有效foreach ($a3 as &$x)，但仅当数组以多个元素开始时才有效？

我意识到在迭代期间修改数组可能不是一个好主意，但由于 PHP 似乎允许这样做，我很好奇为什么上面的工作方式如此。

4

2 回答 2

4

有趣的观察：

echo "foreach:  ";
$a = array(1,2,3);
foreach($a as $v) {
  echo $v, " ";
  if ($v===1) $a[] = 4;
  if ($v===4) $a[] = 5;
}

echo "\nforeach&: ";
$a = array(1,2,3);
foreach($a as &$v) {
  echo $v, " ";
  if ($v===1) $a[] = 4;
  if ($v===4) $a[] = 5;
}

echo "\nwhile:    ";
$a = array(1,2,3);
while(list(,$v) = each($a)) {
  echo $v, " ";
  if ($v===1) $a[] = 4;
  if ($v===4) $a[] = 5;
}

echo "\nfor:      ";
$a = array(1,2,3);
for($v=reset($a); key($a)!==null; $v=next($a)) {
  echo $v, " ";
  if ($v===1) $a[] = 4;
  if ($v===4) $a[] = 5;
}

结果是

foreach:  1 2 3 
foreach&: 1 2 3 4 
while:    1 2 3 4 5 
for:      1 2 3 4 5

这表示：

  • 正常foreach循环对数组的副本进行操作，循环内数组的任何修改都不会影响循环
  • 带有foreach引用值的 a 被强制使用原始数组，但在分配键和值变量后，在每次迭代之前推进数组指针。还有一些优化正在进行，一旦指针到达末尾，就可以防止再次检查。因此，在最后一次迭代开始时，循环被告知再次运行然后完成 - 不再可能发生干扰。
  • 一个while循环与each()前进数组指针一样foreach，但在最后一次迭代后再次显式检查它
  • 每次迭代后for数组指针前进的循环显然在任何时候更改数组都没有问题。
于 2013-01-31T23:54:59.627 回答
3

1.为什么第一个循环 foreach ($this->a1 as &$v) 没有意识到 $v 有另一个元素要迭代？

该行为看起来是由于在每次 foreach 迭代中在数组上前进的内部指针。在数组的最后一次迭代时，即内部指针已经为空时，在数组末尾添加一个数组元素，意味着该元素将不会被迭代。通过对您的代码进行一些修改，可以看出这一点。

class Foo
{
    private $a1 = array();
    private $a2 = array();

    public function f()
    {
        echo '<pre style="font-size: 20px;">';
        echo 'PHP: ' . phpversion() . '<br><br>';

        $this->a1[] = function() { echo 'a1 <br/>'; };
        $this->a1[] = array($this, 'g');
        foreach ($this->a1 as $key => &$v)
        {
           //lets get the key that the internal pointer is pointing to 
           // before the call.
                  $intPtr = (key($this->a1) === null) ? 'null' : key($this->a1);
                echo 'array ptr before key ', $key, ' func call is ',    
                       $intPtr, '<br/>' ;
            call_user_func($v);
            //echo 'count(v) = ' . count($v) . ' ';
        }

        echo '<br><br>';

        // The same thing works fine with a for() loop.
        $this->a2[] = function() { echo 'a2 '; };
        $this->a2[] = array($this, 'h');
        for ($i = 0; $i < count($this->a2); ++$i)
            call_user_func($this->a2[$i]);

        echo '<br><br>';

        // It also works fine using a local array as long as it
        // starts off with more than one element.
        $a3[] = function() { echo 'a3 '; };
        //$a3[] = function() { echo 'a3 '; };
        $i = 0;
        foreach ($a3 as &$x)
        {
            call_user_func($x);
            if ($i++ > 1) // prevent infinite loop
                break;

            // Why does this get called only if $a3 originally starts
            // with more than one element?
            $a3[] = function() { echo 'callback '; };
        }

        echo '</pre>';
    }

    private function g()
    {
        echo 'g() <br>';
        $this->a1[] = function() { echo 'callback '; };
    }

    private function h()
    {
        echo 'h() <br>';
        $this->a2[] = function() { echo 'callback '; };
    }
}

$foo = new Foo;
$foo->f();

输出：

array ptr before key 0 func call is 1
a1 
array ptr before key 1 func call is null <-will not iterate over any added elements!
g() 

a2 h() 
callback 

a3

2.为什么在foreach的第三个循环（$a3 as &$x）期间修改$a3有效，但仅当数组以多个元素开始时才有效？

当然，如果您在内部指针返回 null 之前向数组添加一个元素，那么该元素将被迭代。在您的情况下，如果数组有一个元素，那么在第一次迭代中，内部指针已经返回 null。但是，如果最初有多个元素，则可以在第一次迭代时添加附加元素，因为此时内部指针将指向第二个初始元素。

于 2013-01-31T22:11:18.253 回答