foreach在PHP中遍歷對象時僅訪問公共屬性；2. 受保護和私有屬性不可見，即使在類內部使用foreach($this as...)也是如此；3. 要自定義遍歷行為，可實現(xiàn)Iterator或IteratorAggregate接口；4. 若要檢查包括私有和受保護的屬性，需使用Reflection類；5. get_object_vars()同樣僅返回當前作用域下的公共屬性。因此，foreach的行為是PHP封裝特性的體現(xiàn)，非公共屬性不會被遍歷。

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 introspection (including private), use Reflection .

Understanding this behavior helps avoid confusion when objects don't “l(fā)oop 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.

以上是使用公共對象與私人對象屬性揭開神秘的行為的詳細內容。更多資訊請關注PHP中文網其他相關文章！