How PHP foreach Actually Works with Arrays

By the end of this page, you will understand the real model behind PHP foreach: it does not simply mean “loop over a full copy of the array,” and it also does not behave like while (each(...)). You will learn how foreach behaves when iterating by value vs by reference, how array modifications affect the loop, why internal pointer functions can be misleading, and what rules are safe to follow in real PHP code.

foreach in PHP is a dedicated iteration construct for arrays and traversable objects. The key idea is:

• foreach maintains its own iteration state.
• It is not controlled by reset(), next(), each(), or the array's user-visible internal pointer.
• It may use PHP's internal array structure efficiently rather than making a naive element-by-element PHP-level copy.

A common beginner explanation is that foreach “loops over a copy of the array.” That explanation is useful in some cases, but it is not the full internal truth.

What foreach really guarantees

When you write:

foreach ($array as $value) {
    // ...
}

PHP determines how to iterate through the elements in a way that is stable for the loop. In normal by-value iteration:

• the loop visits the elements that were part of the iteration sequence,
• appending or modifying the array during the loop usually does not make the loop continue over newly added elements,
• changing the traditional array pointer with functions like reset() does not drive the loop.

Think of foreach like reading names from an attendance list.

By value

When iterating by value, it is like the teacher starts class with a prepared list of students to call:

• if someone writes extra names on the whiteboard during class, the teacher usually does not start calling those new names,
• if someone changes the seating position, it does not change the prepared calling order.

By reference

When iterating by reference, it is more like the teacher is not only reading the list but also editing the official roster directly as they go.

That means:

• changes affect the real data immediately,
• the loop variable stays connected to the actual array slot,
• mistakes can have side effects after the loop finishes.

Internal pointer functions

Functions like reset() and each() are like moving a separate bookmark in the same book.

foreach is not reading based on that bookmark. It has its own place-tracking system. So moving the bookmark does not usually change what foreach reads next.

Basic syntax

Iterate by value

foreach ($array as $value) {
    echo $value;
}

Iterate with keys and values

foreach ($array as $key => $value) {
    echo $key . ': ' . $value . PHP_EOL;
}

Iterate by reference

foreach ($array as &$value) {
    $value *= 2;
}
unset($value); // important

Example 1: normal by-value iteration

$numbers = [1, 2, 3];

foreach ($numbers as ) {
      . PHP_EOL;
    [] =  * ;
}

();

Consider this example:

$items = [1, 2, 3];

foreach ($items as $key => $value) {
    echo "$key => $value" . PHP_EOL;
    $items[] = $value + 100;
}

print_r($items);

Step-by-step trace

Before the loop

$items = [1, 2, 3];

The array contains three elements.

First iteration

• key = 0
• value = 1
• output: 0 => 1
• then this runs:

$items[] = 101;

Now the real array becomes:

foreach is one of the most common constructs in PHP because arrays are used everywhere.

1. Processing request data

foreach ($_POST as $field => $value) {
    echo $field . ': ' . trim($value) . PHP_EOL;
}

Used for:

• sanitizing form input,
• validating required fields,
• building error lists.

2. Formatting API responses

foreach ($users as $user) {
    $result[] = [
        'id' => $user['id'],
        'name' => strtoupper($user['name'])
    ];
}

Used when transforming database or API data into response payloads.

3. Updating configuration values

foreach ($config as  => ) {
     ( === ) {
        [] = ;
    }
}

In real codebases, foreach is usually used in predictable, low-surprise ways.

Common patterns

Guard clauses before looping

if (empty($users)) {
    return [];
}

foreach ($users as $user) {
    // process user
}

This avoids unnecessary work and makes intent clear.

Validation during iteration

$errors = [];

foreach ($input as $field => $value) {
    if ($value === '') {
        $errors[$field] = 'This field is required.';
    }
}

Building a new array instead of mutating the current one

$clean = [];

foreach ($records as $record) {
    $clean[] = trim();
}

1. Assuming foreach is controlled by reset() or next()

Broken assumption:

$numbers = [1, 2, 3];

foreach ($numbers as $n) {
    next($numbers);
    echo $n;
}

A beginner may expect this to skip values. It does not work that way.

Avoid it

Use foreach alone, or use pointer-based functions separately. Do not mix the two to control iteration.

2. Modifying the array structure and expecting intuitive results

$numbers = [1, 2, 3];

foreach ($numbers as $n) {
    $numbers[] = $n;
}

This changes the array, but the loop behavior may not match your mental model.

Avoid it

Core rules

• foreach has its own iteration state.
• It does not rely on reset(), next(), or each() to move through elements.
• By-value foreach does not modify the source array unless you explicitly assign into the array.
• By-reference foreach lets you modify the original elements.
• After by-reference iteration, always call unset($value).

Syntax

foreach ($array as $value) {
    // read values
}

foreach ($array as $key => $value) {
    // read keys and values
}

foreach ($array as &$value) {
    // modify values in place
}
unset($value);

Safe patterns

Does PHP foreach loop over a copy of an array?

Not in the simple beginner sense of “PHP duplicates the whole array and loops over that copy every time.” A better explanation is that foreach creates its own stable iteration context.

Does reset() affect a foreach loop?

No. foreach does not use reset() or next() to decide which element comes next.

Why can I change the array inside foreach without an infinite loop?

In normal by-value iteration, foreach does not automatically keep extending its iteration to include everything you append during the loop.

When should I use foreach by reference?

Use it when you intentionally want to modify the original array values in place.

Why do I need unset($value) after foreach (&$value)?

Because the loop variable remains a reference to the last element. If you reuse that variable later, you may accidentally modify the array.

Can foreach be used with objects?

• for loop — useful when you need explicit index control instead of array iteration.
• while loop — helps compare condition-based looping with collection-based looping.
• references in PHP — essential for understanding foreach ($array as &$value).
• copy-on-write — explains why PHP can appear to copy arrays without always duplicating memory immediately.
• array_map — a common alternative when transforming each element into a new array.
• array_filter — related because it processes arrays element by element.
• Traversable — important for understanding how foreach works with objects, not just arrays.
• internal array pointer — directly related to confusion around reset(), next(), and legacy iteration.