The following C code mimics the reference leak behavior of a by-reference foreach loop in PHP. By intentionally leaving current pointing to the last element after the first loop, we can reproduce the same silent array corruption that occurs in PHP.

#include <stdio.h>
int main()
{
    int arr[] = {1, 2, 3, 4};
    int *current;

    //First Loop doubles the array
    for (size_t i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {
        //arr[i] === *(arr + i)
        arr[i] *= 2;
        current = arr + i;
        printf("Current modified:%d\n", *current);
    }

    /*
        After the loop completes, the arr is now {2,4,6,8}. 
        As for current, it is going to have the memory location of the last element (memory location of 8).
    */

    for (size_t i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
    {
        /*
            In each iteration, the memory location of 8 is going to be dereferenced and set to arr[i].
            As a result, the last value will be equal to the value before it
        */
        *current = arr[i];
        printf("Current:%d\n", *current);
    }

    return 0;
}

Just as PHP's $value remains a reference to the last element after a by-reference foreach, current here remains a pointer to arr[3]. Every iteration of the second loop writes into arr[3], ultimately copying the second-to-last value onto the last element.

An easier way to unpack nested array elements

$array = [
    [1, 2],
    [3, 4],
];

foreach ($array as [$a, $b]) {
    echo "A: $a; B: $b\n";
}

Definitely relevant for PHP 7+

1. You can't change array during iteration

Foreach WILL NOT LOOP through new values added to the array 
<?php
while inside the loop.
$a = [1, 2, 3];
foreach ($a as $k => $v) {
    echo $v;

    if ($v === 2) {
        $v[] = 4;
    }
}
?>
Output: 123
But the original array was modified: [1, 2, 3, 4]

Foreach WILL LOOP through values deleted from the array while inside the loop.
<?php
$a = [1, 2, 3];
foreach ($a as $k => $v) {
    echo $v;

    if ($v === 2) {
        unset($a[2]);
    }
}
?>
Output: 123
But the original array was modified: [1, 2]

2. But If you iterate by reference using foreach ($arr as &$v) then $arr is turned into a reference and you can change it during iteration

Foreach WILL LOOP through new values added to the array while inside the loop.
<?php
$a = [1, 2, 3];
foreach ($v as &$v) {
    echo $v;

    if ($v === 2) {
        $v[] = 4;
    }
}
?>
Output: 1234

Foreach WILL NOT LOOP through values deleted from the array while inside the loop.
<?php
$a = [1, 2, 3];
foreach ($a as $k => &$v) {
    echo $v;

    if ($v === 2) {
        unset($a[2]);
    }
}
?>
Output: 12

<?php
$array = [
    [1, 2, 3],
    [3, 4, 6],
];

foreach ($array as [$a, $b]) {
    // Observe que não existe $c aqui.
    echo "$a $b\n";
}

foreach ($array as [, , $c]) {
    // Pulando $a e $b
    echo "$c\n";
}
?>

I would like to correct this example above!
The answer of this algorithm is:

1 2
3 4
3
6

As well as numerically-indexed arrays, nested associative arrays can also be unnested in the foreach()

<?php
$records = [
    ['name' => 'Alice', 'address' => '...'],
    ['name' => 'Bob', 'address' => '...'],
    ['name' => 'Chris', 'address' => '...'],
    ...];

foreach($records as ['name' => $name]) {
    echo "$name\n";
}

foreach($records as ['address' => $address, 'name' => $name]) {
    echo "$name @ $address\n";
}
?>

The usual warnings about undefined array keys will occur if any of the element arrays lack the requested key.

One additional detail, the key is still just an ordinary string-valued expression, so...
<?php

$field = 'address';
foreach($records as [$field => $value]) {
    echo "$value\n";
}
?>
If the value of $field changed within the loop, the new field would be accessed in subsequent iterations.