Why does PHP's foreach advance the pointer of its array (only) once?

Question

This is a question of curiosity about the reasons behind the way foreach is implemented within PHP.

Consider:

$arr = array(1,2,3);
foreach ($arr as $x) echo current($arr) . PHP_EOL;

which will output:

2
2
2

I understand that foreach rewinds array pointers to the beginning; however, why does it then increment it only once? What is happening inside the magic box?? Is this just an (ugly) artefact?

---

Thanks @NickC -- for anyone else curious about zval and refcount, you can read up on the basics here

Answer 1

Right before the first iteration the $array is "soft copied" for use in foreach. This means that no actual copy is done, but only the refcount of the zval of $array is increased to 2.

On the first iteration:

1. The value is fetched into $x.
2. The internal array pointer is moved to the next element, i.e. now points to 2.
3. current is called with $array passed by reference. Due to the reference PHP cannot share the zval with the loop anymore and it needs to be separated ("hard copied").

On the following iterations the $array zval thus isn't anymore related the the foreach zval anymore. Thus its array pointer isn't modified anymore and current always returns the same element.

By the way, I have written a small summary on foreach copying behavior. It might be of interest in the context, but it does not directly relate to the issue as it talks mostly about hard copying.

Answer 2

See how interesting, if we change the code just a little bit:

$arr = array(1,2,3);
foreach ($arr as &$x) echo current($arr) . PHP_EOL;

We got this output:

2
3

Some interesting references:

http://nikic.github.com/2011/11/11/PHP-Internals-When-does-foreach-copy.html

http://blog.golemon.com/2007/01/youre-being-lied-to.html

Now, try this:

$arr = array(1,2,3);
foreach ($arr as $x) { $arr2 = $arr; echo current($arr2) . PHP_EOL; }

Output:

2
3
1

This is very curious indeed.

And what about this:

$arr = array(1,2,3);
foreach ($arr as $x) { $arr2 = $arr; echo current($arr) . ' / ' . current($arr2) . PHP_EOL; }
echo PHP_EOL;
foreach ($arr as $x) { $arr2 = $arr; echo current($arr2) . ' / ' . current($arr2) . PHP_EOL; }

Output:

2 / 2
2 / 2
2 / 2

2 / 2
3 / 3
1 / 1

It seems what happens is just as written in NickC answer, plus the fact that when passing an array as an argument to current function, as it is passed by reference, something inside there does modify the array passed as argument to it...

Answer 3

It doesn't answer the question, but you can use a workaround using \ArrayIterator

$arr = new ArrayIterator(array(1,2,3));
foreach ($arr as $x) echo $arr->current() . PHP_EOL;

1
2
3

You can even use Iterator.next() to advance the iteration.

Answer 4

This is the results of your code opcode analysis with php 5.3.

See this example : http://php.net/manual/en/internals2.opcodes.fe-reset.php

number of ops: 15 compiled vars: !0 = $arr, !1 = $x

line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   INIT_ARRAY                                       ~0      1
   1      ADD_ARRAY_ELEMENT                                ~0      2
   2      ADD_ARRAY_ELEMENT                                ~0      3
   3      ASSIGN                                                   !0, ~0
   3     4    > FE_RESET                                   $2      !0, ->13
   5  > > FE_FETCH                                         $3      $2, ->13
   6  >   ZEND_OP_DATA                                             
   7      ASSIGN                                                   !1, $3
   8      SEND_REF                                                 !0
   9      DO_FCALL                                      1          'current'
  10      CONCAT                                           ~6      $5, '%0A'
  11      ECHO                                                     ~6
  12    > JMP                                                      ->5
  13  >   SWITCH_FREE                                              $2
  14    > RETURN                                                   1

See NikiC's answer for details, but you see at line #8 that !0 never change in the loop.(5-12)