The IteratorAggregate interface is utilized to create an external Iterator, enabling traversal of custom class objects using the foreach loop:
class FooBarClass implements IteratorAggregate
{
public $property = "Nothing to see";
public function __construct()
{
}
public function getIterator()
{
return new ArrayIterator($this);
}
}
$obj = new FooBar;
foreach($obj as $key => $value) {
print(var_dump($key, $value) . "\n");
}
On the other hand, the Iterator interface also serves as a means for external iterators, allowing classes or objects to internally iterate themselves:
class myIterator implements Iterator
{
private $position = 0;
private $array = array('one', 'two', 'three');
function rewind()
{
$this->position = 0;
}
function current()
{
return $this->array[$this->position];
}
function key()
{
return $this->position;
}
function next()
{
++$this->position;
}
function valid()
{
return isset($this->array[$this->position]);
}
}
Despite their differences, both interfaces facilitate object traversal in a similar manner as mentioned with IteratorAggregate.
The distinction lies in the fact that IteratorAggregate is simpler to implement than an Iterator and generally offers faster performance. However, it solely focuses on traversal and lacks methods like next(), key(), etc., which are not called during foreach iteration.
Conversely, utilizing the Iterator (or more precisely an OuterIterator or (simpler) an IteratorIterator) provides finer control over object iteration, allowing custom exceptions for next(), key(), prev() failures, caching(), etc.
Note that some of PHP's internal classes implemented this interface directly, while any user-defined class requiring Traversable implementation must use either IteratorAggregate, Iterator, or another descendant from Traversable. More information can be found in Pro PHP by Kevin McArthur p. 143f.
The Traversable interface itself acts as an abstract base interface without any specific methods listed in the synopsis, making it non-instantiable but useful for checking if a class is traversable via foreach loops.
Traversable {
}
An important aspect to note is that objects and arrays do not implement "Traversable," yet can still be traversed using foreach; however, you cannot verify foreach compatibility through instanceof checks or type hints.
$myarray = array('one', 'two', 'three');
$myobj = (object)$myarray;
if ( !($myarray instanceof \Traversable) ) {
print "myarray is NOT Traversable";
}
if ( !($myobj instanceof \Traversable) ) {
print "myobj is NOT Traversable";
}
As previously mentioned, all objects can be traversed via foreach, granting access only to public properties. Quoting from the PHP manual on Object Iteration:
PHP 5 provides a way for objects to be defined so it is possible to
iterate through a list of items, with, for example a foreach
statement. By default, all visible properties will be used for the
iteration.
In essence, if encapsulating an object with private and protected values necessitates getter and setter methods for access, consider implementing IteratorAggregate or Iterator within your class to make these values accessible in foreach loops as required.
To summarize, objects adhering to the Traversable interface (through Iterator or IteratorAggregate) exhibit array-like behavior but do not mandate iteration enhancement. Implementing Iterator is essential to modify their behavior, extending this principle to built-in classes as well.