The foreach() loop is a fundamental construct used to iterate over arrays and objects for repetitive processing.

This guide covers the following topics:

  1. Syntax of the foreach() loop
  2. Handling array indices
  3. Using the $key and $value syntax in foreach()
  4. Applying conditional statements
  5. Iterating over objects
  6. Using the break and continue keywords
  7. Storing and adding data in arrays and associative arrays (two-dimensional arrays)
  8. Using &$value (reference variables)

The foreach() loop is used to iterate over arrays and objects for repetitive processing.

This means it only works on arrays and objects. Using it with other data types or uninitialized variables will cause an error. In other words, the foreach() loop is valid exclusively for arrays and objects and cannot be used with other data types or uninitialized variables.

Syntax

The foreach() loop has two syntax forms:

  • Loop that processes only the values of an array or object
  • Loop that processes both keys and values of an array or object

Loop to Process Only Values of an Array or Object

PHP - Syntax 배열 또는 객체의 값만을 가져와서 반복 작업을 수행하는 구문 
foreach (iterable_expression as $value) {
    // Code to be executed using $value
}

This syntax iterates over the values of an array or object only. The $value variable is updated with each element’s value on every iteration. Let's look at an example.

PHP Example: Processing Only Values of an Array or Object 
$fruits = ['apple', 'banana', 'orange'];

foreach ($fruits as $value) {
    echo $value . '<br>';
}
Output

In this example, the $value variable holds only the values from the array or object. On each loop iteration, it updates to the next element’s value, which is then output. This syntax allows easy access to the values for any desired operation.

A loop is a structure in programming that repeatedly executes the same block of code until a certain condition is met. The term originates from the idea that the structure is connected like a loop.

Loop to Process Both Keys and Values of an Array or Object

PHP 
foreach (iterable_expression as $key => $value) {
    // Code to be executed using $key and $value
}

This syntax iterates over both keys and values of an array or object. The $key variable represents the key, while $value holds the corresponding value. Let's see an example.

PHP 
$fruits = [
	'apple' => 'red',
	'banana' => 'yellow',
	'orange' => 'orange'
];

foreach ($fruits as $key => $value) {
    echo 'Fruit: ' . $key . ', Color: ' . $value . '<br>';
}
Output

In this example, the $key variable contains the key from the array or object, while $value holds its corresponding value. On each iteration, the foreach() loop updates both variables with the next key and value, allowing you to access both simultaneously for processing.

Notes

PHP supports an Alternative syntax for control structures such as the while loop, known as the "colon syntax." This is mainly used to improve readability when mixing PHP and HTML.

PHP Alternative foreach() Syntax: 
<?php foreach (iterable_expression as $value): ?>
    <?php // Code block to execute ?>
<?php endforeach; ?>
PHP Alternative foreach() Syntax: 
<?php foreach (iterable_expression as $key => $value): ?>
    <?php // Code block to execute ?>
<?php endforeach; ?>

Let's look at examples of handling array indices using the foreach() loop.

Finding an Array Index

Here is a simple example that uses the foreach() loop to search for a specific value in an array and retrieve the corresponding index.

PHP 
$fruits = ['apple', 'banana', 'orange'];

$searchValue = 'banana';
$searchIndex = -1;

foreach ($fruits as $index => $value) {
    if ($value === $searchValue) {
        $searchIndex = $index;
        $found = true;
    }
}

if ($searchIndex !== -1) {
    echo "Found '" . $searchValue . "' at index " . $searchIndex . ".";
} else {
    echo "Did not find '" . $searchValue . "'.";
}

// Output: "Found 'banana' at index 1."

In this example, the $searchValue variable holds the value we want to find, and $searchIndex is initialized to -1. The foreach() loop iterates through the array, checking if the current value matches the search value. If a match is found, $searchIndex is updated with the current index.

After the loop finishes, the script checks $searchIndex to determine whether the value was found and outputs an appropriate message. In this case, it will print Found 'banana' at index 1. If the value was not found, it outputs Did not find 'banana'.

Finding the Last Index of an Array

Here is a simple example showing how to find the last index of an array using a foreach() loop. To find the last index, you can iterate through the entire array, updating a variable with the current index at each step.

PHP 
$fruits = ['apple', 'banana', 'orange'];

$lastIndex = null;

foreach ($fruits as $index => $value) {
    $lastIndex = $index;
}

if ($lastIndex !== null) {
    echo 'Last index: ' . $lastIndex;
} else {
    echo 'The array is empty.';
}

// Output: "Last index: 2"

In this example, the $lastIndex variable is declared and initialized to null. The foreach() loop iterates over the array, continuously updating $lastIndex with the current index. When the loop finishes, $lastIndex contains the last index of the array.

This example demonstrates how to use the $key and $value syntax in a foreach() loop to handle both keys and values in an array.

PHP 
$person = [
    'name' => 'John',
    'age' => 30,
    'occupation' => 'Engineer',
    'country' => 'USA'
];

echo 'Personal Information:<br>';

foreach ($person as $key => $value) {
    echo ucfirst($key) . ': ' . $value . '<br>';
}

In this example, $person is an associative array, where each key corresponds to a value. Inside the foreach() loop, we use two variables, $key and $value, to access each key and its associated value in every iteration.

During each loop cycle, $key holds the current key, and $value holds the corresponding value. The ucfirst() function capitalizes the first letter of each key before outputting the information.

Running this example will produce the following output:

Output

Using the $key and $value syntax in foreach() allows you to work with both the keys and values of an array simultaneously, enabling you to process each element according to your needs.

The foreach() loop is typically used to iterate over all elements in an array or object. However, in some cases, you may want to process only the elements that meet specific conditions. By combining the foreach() loop with conditional statements, you can selectively handle elements based on your criteria.

Here's an example of using a foreach() loop along with an if condition to print only even numbers from a numeric array:

PHP 
$numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

echo 'Even numbers:<br>';

foreach ($numbers as $number) {
    if ($number % 2 === 0) {
        echo $number . '<br>';
    }
}

In this example, the $numbers array contains a list of integers. The foreach() loop iterates over each element, and on each iteration, the current value is assigned to the $number variable.

Inside the loop, the if statement checks whether $number is even by using the modulo operator (%). If the condition is met (i.e., the number is divisible by 2), it gets printed.

Output

This technique allows you to filter elements during iteration and apply specific logic only when certain conditions are satisfied. It's especially useful when working with datasets that require validation or conditional processing.

The foreach() loop can be used not only with arrays but also to iterate over the properties of an object. In PHP, when iterating over an object using foreach(), each public property is treated as a key-value pair.

Here's an example that demonstrates how to loop through an object using foreach():

PHP 
class Person {
    public $name;
    public $age;
    public $occupation;

    public function __construct($name, $age, $occupation) {
        $this->name = $name;
        $this->age = $age;
        $this->occupation = $occupation;
    }
}

$person = new Person('John', 30, 'Engineer');

foreach ($person as $key => $value) {
    echo ucfirst($key) . ': ' . $value . '<br>';
}

In this example, the Person class has three public properties: name, age, and occupation. An instance of the class is created, and its properties are accessed using a foreach() loop.

On each iteration, $key holds the name of the property, and $value holds its corresponding value. The ucfirst() function is used to capitalize the first letter of each property name before outputting it.

Output

Using foreach() with objects is useful when you need to process an unknown or dynamic set of properties. It allows you to loop over all public properties in a flexible and consistent way.

Note:
While foreach() can access an object's properties, it cannot iterate over its methods. Methods are functions defined within a class and are not considered iterable by foreach(). This loop is specifically designed for handling arrays and object properties, not executable code blocks.

The foreach() loop in PHP supports both the break and continue keywords to control loop execution.

  • break immediately exits the loop and proceeds to the next line of code after the loop.
  • continue skips the current iteration and proceeds to the next cycle of the loop.

Let's look at how each keyword works within a foreach() loop.

Using break

Code Explanation
The break keyword is used to exit from a loop (or switch statement) as soon as a certain condition is met.

PHP 
$numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

echo 'Finding the first even number:<br>';

foreach ($numbers as $number) {
    if ($number % 2 === 0) {
        echo 'First even number: ' . $number . '<br>';
        break;
    }
}
Output

In this example, the foreach() loop iterates through the array until it finds the first even number. When it does, break stops the loop immediately.

Using continue

Code Explanation
The continue keyword is used to skip the remaining code in the current iteration and jump to the next loop cycle.

PHP 
$numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

echo 'Printing even numbers only:<br>';

foreach ($numbers as $number) {
    if ($number % 2 !== 0) {
        continue;
    }
    echo $number . '<br>';
}
Output

Here, the continue statement skips any number that is not even. As a result, only even numbers are printed.

Using break and continue in foreach() gives you greater control over how elements are processed, especially when dealing with conditions or early exits.

This section demonstrates how to use the foreach() loop to store and add data to both indexed arrays and associative arrays (two-dimensional arrays).

Storing and Adding Data to an Indexed Array

PHP 
$numbers = [1, 2, 3, 4, 5];
$newNumbers = [];

// Add 1 to each element and store the result in a new array
foreach ($numbers as $number) {
    $newNumbers[] = $number + 1;
}

// Output the contents of the new array
foreach ($newNumbers as $number) {
    echo $number . '<br>';
}

In this example, $numbers is the original array, and $newNumbers is an empty array. The foreach() loop iterates over each element of $numbers, adds 1 to it, and stores the result in $newNumbers.

After the loop completes, $newNumbers contains the incremented values of the original array. The second foreach() loop then prints out these values.

Output

Storing and Adding Data to an Associative Array (Two-Dimensional Array)

PHP 
// Original array data
$studentsData = [
    ['name' => 'John', 'age' => 25, 'score' => 85],
    ['name' => 'Alice', 'age' => 23, 'score' => 90]
];

// Initialize an empty associative array (two-dimensional)
$students = [];

// Copy data from $studentsData to $students
foreach ($studentsData as $student) {
    $students[] = $student;
}

// Add a new record
$students[] = ['name' => 'Bob', 'age' => 22, 'score' => 78];

// Output each student's information
foreach ($students as $student) {
    echo 'Name: ' . $student['name'] . ', Age: ' . $student['age'] . ', Score: ' . $student['score'] . '<br>';
}

Here, $studentsData contains the initial set of student records. Using foreach(), each record is added to a new array named $students. After that, a new record for Bob is appended directly to the $students array.

Finally, another foreach() loop is used to display the name, age, and score for each student.

Output

This technique is useful for processing structured data where each entry is represented as an associative array. By using foreach(), it's easy to dynamically build and display datasets of any size or structure.

You can use &$value in a foreach() loop to work with array elements by reference. This allows you to modify the original array values directly within the loop, which can be useful in certain scenarios where in-place updates are needed.

Here's an example of how to modify array values using references in a foreach() loop:

PHP 
$numbers = [1, 2, 3, 4, 5];

// Modify array elements by reference
foreach ($numbers as &$value) {
    $value = $value * 2;
}

// Output the modified array
foreach ($numbers as $number) {
    echo $number . '<br>';
}
Output

In the example above, the $numbers array is iterated using &$value, which means each element is accessed by reference rather than by value. Any change made to $value directly affects the corresponding element in the original array.

Because &$value modifies the source array, it should be used with care to avoid unintended side effects. When used appropriately, it can be a powerful tool for working with arrays efficiently.

When to Use &$value in foreach()

  • When modifying array elements: Using &$value in a foreach() loop allows you to update values directly. In some contexts, you may also modify the keys.
  • When handling large datasets: Referencing values directly can help reduce memory usage and improve performance compared to copying values into new variables.
  • When working with nested arrays: You can use &$value to locate and update specific values within a multi-dimensional array as you loop through it.
  • When conditionally modifying elements: A foreach() loop with &$value is useful when you need to update only those elements that meet certain criteria.

Only use &$value when it's truly necessary. Accidental references can lead to bugs or hard-to-read code. Be especially cautious with nested arrays or loops, and always reset or unset reference variables when they're no longer needed.

References

See also