Foreach only accesses public properties when traversing objects in PHP; 2. Protected and private properties are not visible, even if you use foreach($this as...) inside the class; 3. To customize the traversal behavior, you can implement the Iterator or IteratorAggregate interface; 4. To check for properties that include private and protected, you need to use the Reflection class; 5. get_object_vars() also returns only the public properties under the current scope. Therefore, foreach's behavior is the embodiment of PHP encapsulation characteristics, and non-public attributes will not be traversed.

When working with objects in PHP and using foreach to iterate over their properties, you might notice that the behavior changes depending on whether properties are public, private, or protected. This can be confusing — especially if you're expecting foreach to behave like it does with arrays. Let's clarify how foreach interacts with object properties and why visibility matters.

How foreach Iterates Over Object Properties

In PHP, when you use foreach on an object, only public properties are accessible by default . This is a key difference from iterating over arrays, where all elements are visible.

Consider this simple class:

 class User {
    public $name = 'Alice';
    protected $age = 30;
    private $salary = 50000;
}

Now, let's iterate over an instance:

 $user = new User();
foreach ($user as $key => $value) {
    echo "$key: $value\n";
}

Output:

 name: Alice

Only the public property name shows up. The protected and private properties are completely invisible to foreach .

Why Does This Happen?

PHP's foreach operates on the public interface of an object. When you iterate over an object, PHP doesn't directly access the internal structure. Instead, it follows visibility rules strictly — just like any other context in object-oriented programming.

This means:

• public properties: accessible and iterable.
• protected properties: not accessible from outside the class or its children, so skipped.
• private properties: only accessible within the class itself, so also skipped.

Even if you're inside a method of the class, foreach($this as ...) will still only show public properties — which often surprises developers.

 class User {
    public $name = 'Alice';
    private $salary = 50000;

    public function debug() {
        foreach ($this as $key => $value) {
            echo "$key: $value\n"; // Only prints 'name'
        }
    }
}

Yes — even from inside the class, foreach ignores private and protected properties.

Controlling Iteration with Iterator Interface

If you need to expose non-public properties (or any custom data) during iteration, you can implement the Iterator or IteratorAggregate interface.

For example, using IteratorAggregate :

 class User implements IteratorAggregate {
    public $name = 'Alice';
    protected $age = 30;
    private $salary = 50000;

    public function getIterator(): Traversable {
        return new ArrayIterator([
            'name' => $this->name,
            'age' => $this->age,
            'salary' => $this->salary
        ]);
    }
}

Now, foreach will show all three:

 foreach ($user as $key => $value) {
    echo "$key: $value\n";
}

Output:

 name: Alice
age: 30
Salary: 50000

This gives you full control over what appears during iteration — useful for debugging, serialization, or APIs.

Common Pitfalls and Tips

• Don't assume foreach sees all properties — it doesn't. It only sees public ones.
• Even inside a class, foreach($this as ...) skips private/protected.
• If you're debugging and wonder why some properties aren't showing up, check visibility.
• Use var_dump() or get_object_vars() for complete property inspection:

 var_dump(get_object_vars($user)); // Shows public properties only

Note: get_object_vars() also only returns publicly visible properties in the current scope.

To access private/protected properties, you'd need to use Reflection:

 $reflection = new ReflectionObject($user);
$properties = $reflection->getProperties();

foreach ($properties as $prop) {
    echo $prop->getName() . ': ' . $prop->getValue($user) . "\n";
}

Summary

• foreach on objects only iterates over public properties.
• Visibility rules apply strictly — even from inside the class.
• Use IteratorAggregate or Iterator to customize what foreach exposes.
• For full introduction (including private), use Reflection .

Understanding this behavior helps avoid confusion when objects don't "loop through" as expected. It's not a bug — it's PHP enforcing encapsulation, one loop at a time.

Basically, if it's not public, foreach won't see it.

The above is the detailed content of Demystifying foreach Behavior with Public vs. Private Object Properties. For more information, please follow other related articles on the PHP Chinese website!