Strange behavior while modifying array that is being iterated

Answer 1

Modifying array while iterating over it is generally unsafe and can result in unexpected behaviour.

Answer 2

Well your example unsets every element which is not divisible by 3. Now in this $arr[$x+1] += 1; You are increasing value by one and in the next iteration it will be unset since it is not divisible by 3.

Answer 3

That's expected behaviour though, it unsets everything which isn't a multiple of 3, then subsequently tries to increment an unset variable by 1.

Answer 4

You can't alter the values within a foreach iterator unless you're passing by reference. As the PHP manual page states:

Note: Unless the array is referenced, foreach operates on a copy of the specified array and not the array itself. foreach has some side effects on the array pointer. Don't rely on the array pointer during or after the foreach without resetting it.

As such, you'll need to update the foreach line to:

foreach( $arr as $x => &$line){
...

Answer 5

What are you trying to achieve with this?

if( $x % 3){ 

When $x is 0, $x % 3 is 0, therefore false; when $x is 1, $x % 3 is 1, therefore true; when $x is 2, $x % 3 is 2, therefore true... so when $x is 0 it will increment $x+1 (1), then promptly unset entries 1 and 2; increment $x+1 when $x is 3 (entry 4); then unset entries 4 and 5, etc.

Do you mean

if(( $x % 3) == 0) { 

Answer 6

Your second example is still expected behaviour... You're working on a copy of the array and its values, not the actual array values, unless you use "by reference"

foreach( $arr as $x => &$line){
    if( preg_match("/word$/", $line)){
        $line = preg_replace( "/word$/", '', $line);
        $arr[$x+1] = 'word ' . $arr[$x+1];
    }
}
unset($line);

Note the use of the &$line rather than $line, and it's always safest to unset after the loop has finished

EDIT

Quoting from the PHP manual:

Note: Unless the array is referenced, foreach operates on a copy of the specified array and not the array itself. foreach has some side effects on the array pointer. Don't rely on the array pointer during or after the foreach without resetting it.

EDIT

I don't recommend the use of references in a foreach(), it is really slow, in my case it was 16x slower. The solution in to add this line: $line = $arr[$x]; in the beginning of the loop, it seems to do some magick tricks and everything works as I would expect

Not really a magic trick. It simply overwrites the value of $line extracted via the foreach loop with $line directly from the array via the key ($x).

YMMV, but it doesn't seem much slower to me.

The following test script:

$arr = range(1,9999);


$callStartTime = microtime(true);

foreach($arr as &$line) {
    $line += 1;
}
unset($line);

$callEndTime = microtime(true);
$callTime = $callEndTime - $callStartTime;
echo '<br />Call time to access by reference was '.sprintf('%.4f',$callTime)." seconds<br />\n";


foreach($arr as $x => &$line) {
    $line += 1;
}
unset($line);

$callEndTime = microtime(true);
$callTime = $callEndTime - $callStartTime;
echo '<br />Call time to access by reference (retrieving key as well) was '.sprintf('%.4f',$callTime)." seconds<br />\n";


$callStartTime = microtime(true);

foreach($arr as $x => $line) {
    $arr[$x] += 1;
}
unset($line);

$callEndTime = microtime(true);
$callTime = $callEndTime - $callStartTime;
echo '<br />Call time and then access array element directly was '.sprintf('%.4f',$callTime)." seconds<br />\n";

$callStartTime = microtime(true);

foreach(array_keys($arr) as $x) {
    $arr[$x] += 1;
}

$callEndTime = microtime(true);
$callTime = $callEndTime - $callStartTime;
echo '<br />Call time to access array_keys was '.sprintf('%.4f',$callTime)." seconds<br />\n";

returns the following timings:

Call time to access by reference was 0.0018 seconds
Call time to access by reference (retrieving key as well) was 0.0039 seconds
Call time to access key and then access array element directly was 0.0077 seconds
Call time to access array_keys was 0.0071 seconds