Foreach operates by default in PHP as a copy of the array rather than the original array, which means that the loop uses an independent internal pointer, which is not affected by the original array pointer state, and the modification of the original array during the loop usually does not change the iteration process; 1. When the loop starts, PHP creates an implicit copy of the array, ensuring that the iteration starts from the first element, ignoring the previous operations of the original array pointer such as next() and reset(); 2. Although large arrays optimize memory due to the copy-on-write mechanism, there is still potential memory overhead; 3. Modifying the original array (such as adding elements) in the loop will not affect the number of elements and traversal content of the current loop, because iteration is based on the initial snapshot; 4. Using reference (&) can avoid copying and directly modifying the original array value, but unset references variables after the loop to prevent unexpected side effects; 5. This replica mechanism guarantees the stability and predictability of foreach, and understanding this behavior helps avoid confusion during debugging.

When you work with arrays in PHP and use foreach , it might seem like you're directly iterating over the original array — but there's a subtle detail many developers overlook: foreach operates on a copy of the array by default , not the original array itself.

This behavior is often called "the hidden copy," and understanding it can prevent confusion, especially when dealing with array points or modifying arrays during iteration.

How foreach Works Behind the Scenes

When foreach starts, PHP creates an internal copy of the array you're iterating over (unless you're using references). This means:

• Changes to the original array's pointer (like with next() , reset() , etc.) don't affect the foreach loop.
• Modifications to the original array during the loop usually don't impact the iteration (with some exceptions).

 $array = ['a', 'b', 'c'];
reset($array);
next($array); // Move pointer forward

foreach ($array as $value) {
    echo key($array) . ' => ' . $value . "\n";
}

Output:

 0 => a
1 => b
2 => c

Even though we called next() before the loop, foreach starts from the beginning because it uses a copy with its own internal pointer , independent of the original array's pointer.

The Hidden Copy and Memory Implications

Because foreach copies the array, large arrays can increase memory usage:

 $bigArray = range(1, 1000000);
foreach ($bigArray as $value) {
    // $bigArray is copied in memory
}

This duplication is temporary and optimized in modern PHP versions (especially with copy-on-write), but it's still something to consider in memory-sensitive contexts.

?? Note: PHP uses copy-on-write (COW) optimization. The actual duplication only happens if you modify the original array during the loop. If not, the same underlying data may be shared.

Modifying the Original Array Inside foreach

If you modify the original array while inside a foreach loop, the hidden copy usually remains unaffected — because it's already been made.

 $array = [1, 2, 3];
foreach ($array as $value) {
    $array[] = $value; // appending to original
}
print_r($array);

Output:

 Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 1
    [4] => 2
    [5] => 3
)

The loop still runs only 3 times (over the original 3 elements), even though we added more to $array . The hidden copy contains only the initial elements.

Using References to Avoid the Copy

If you want to modify the original array's values or avoid copying large arrays, use references with & :

 $items = [10, 20, 30];
foreach ($items as &$item) {
    $item *= 2;
}
unset($item); // Always unset to avoid accidental aliasing
print_r($items);

Output:

 Array
(
    [0] => 20
    [1] => 40
    [2] => 60
)

Now, no value copy is made, and changes affect the original directly. But note:

• You're still not accessing the array's external pointer.
• Be cautious: using references can lead to subtle bugs if not cleaned up (eg, the infamous reference leftover issue).

Key Takeaways

• foreach works on a copy of the array by default.
• The array pointer of the original array is ignored ; foreach always starts from the beginning.
• Modifying the original array during iteration won't affect the loop's elements or count.
• Use references ( & ) to modify values or reduce memory overhead.
• Always unset() reference variables after the loop to avoid unintended side effects.

The hidden copy behavior is usually what you want — it makes foreach predictable and safe. But when you're debugging pointer issues or expecting real-time changes, remembering this detail can save hours of confusion.

Basically: foreach doesn't see the original array — it sees a snapshot.

The above is the detailed content of The Hidden Copy: How foreach Handles Array Pointers by Default. For more information, please follow other related articles on the PHP Chinese website!