An easier way to unpack nested array elements
$array = [
 [1, 2],
 [3, 4],
];
foreach ($array as [$a, $b]) {
 echo "A: $a; B: $b\n";
}

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.

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.