It’s a generally accepted fact that more readable code is more maintainable and easier for other developers to pick up. Simple scripts can be easily worked around these principles, but the moment we explore any complexity the intricacies of the language impede basic readability - just look at the average Perl script, for example.

The Standard PHP Library (SPL) religiously utilises iteration for some outstanding results (and great code simplicity). PHP’s native language constructs are very readable, and by simplifying our code we can build applications faster and more effectively. The SPL demonstrates this with the power of its classes integrating with language constructs, such as the foreach loop.

Looping is probably one of the most common elements of PHP applications. Take this simple example, for instance:

<?php
$vegetables = array("tomato", "carrot", "cauliflower");
foreach ($vegetables as $vegetable) {
    print $vegetable . "\n";
}
?>

As you can see, this is a very simple example, and probably doesn’t reflect a lot of the loops in your day-to-day development. They might look a little more like this:

<?php
foreach (($records = $db->get($this, RECORDS_PER_PAGE)->rs->array) as $row) {
    print $row;
}
?>

That’s a bit of an exaggeration - assignments in a foreach loop is not a good idea and (thankfully) isn’t very common - but it demonstrates the fundamental problem with common uses of loops - they stop making sense.

What if we could improve that? Consider this example:

<?php
foreach ($db as $row) {
    // ...
}
?>

Where $db is an object. That’s right, iterating over an object. Now, typically when we iterate over an object, we get an array of its public properties. In this case, we can control from within the object $db precisely what we get when we iterate over it, by implementing the Iterator interface.

This can work just fine, as when you iterate over an object, you can probably write a little bit of code within that object so that it knows what you wanted in the previous more complex example. For example, if you’re running a database query then fetching the resultset, you can instead run the database query then “fetch” the entire database object. When you iterate over the database object, it now knows that you really want to iterate over the resultset - and it can do just that.

Here’s an example of the class that $db might be an instance of:

<?php
class MyDatabase implements Iterator
{
    private $data = array();
 
    public function __construct()
    {
        $this->data = array("Result 1", "Result 2");
    }
 
    public function rewind() {
        reset($this->data);
    }
 
    public function current() {
        $var = current($this->data);
        return $var;
    }
 
    public function key() {
        $var = key($this->data);
        return $var;
    }
 
    public function next() {
        $var = next($this->data);
        return $var;
    }
 
    public function valid() {
        $var = $this->current() !== false;
        return $var;
    }
}
?>

As you can see, it’s a perfectly normal class, implementing methods with names close to the standard array functions. When your object is iterated over, these Iterator methods will be called where needed. What actually happens inside the methods is up to you — in this instance, we store the data in an array, $this->data, but it could as well be a complex recordset or XML node tree. As long as calling the appropriate methods performs the action needed, our class can manage its data internally and all we have to do is iterate over it like any other PHP array.

And just for readability, we could always go a step further:

<?php
$books = &$db; // $books is now our $db object
foreach ($books as $book) {
    // ...
}
?>

Now isn’t that what you’d like to see when working with someone else’s code?

For further reading on object iteration, check out the manual page on iterating objects. Also take a look the standard PHP library functions.