Chapter 6. Iterators and SPL
Iteration is a key component of PHP programming. Whenever you loop through the elements of an array, the rows in a database, the files in a directory, or the lines of an HTML table, that's iteration.
Iteration takes many forms in PHP, but the most popular two are foreach and while loops. For example:
foreach ($array as $key => $value) {
// iterate through array elements
}
reset($array);
while (list($key, $value) = each($array)) {
// iterate through array elements
}Although both of these constructs solve the same problem, foreach is shorter and easier. Iteration using a while loop can also introduce subtle bugs into your code, like in this example:
// $path is valid and readable
$dir = opendir($path);
while ($file = readdir($dir)) {
print "$file\n";
}
closedir($dir);This code opens and iterates through files in a directory. When there are no more files, readdir( ) returns false, the while ends, and the directory is closed. It works perfectly.
It works perfectly, that is, until someone places a file named 0 in the directory. Then, $file is set to 0, and the loop terminates early because while (0) evaluates as false. Oops.
The correct way to read files from a directory is as follows:
while (false != = ($file = readdir($dir))) {
print "$file\n";
}You need to do a strict equality check using the = = = operator. Even = = gives you the wrong results because PHP autoconverts $file from a string to a Boolean.
Since there's no reason for you (or anyone else) to remember this, PHP 5 has an improved foreach that iterates through certain types of objects in a controlled manner. These objects are called iterators.
Iterators help eliminate problems in your code. For instance, the Standard PHP Library (SPL) extension provides a DirectoryIterator:
foreach (new DirectoryIterator($path) as $file) {
print "$file\n";
}This example produces the same results as the earlier code that uses the directory functions, but this code is shorter and safer because you cannot forget the = = = comparison.
SPL contains both standalone iterators and iterators meant to be chained together in a sequence. For example, you can pipe the output of a DirectoryIterator to an iterator that discards files that don't end in .html. This design helps you create a series of modular iterators that you can quickly combine to solve tasks.
SPL is bundled with PHP 5 and enabled by default, so it's essentially part of PHP 5 itself. Table 6-3 at the end of this chapter has a complete overview of all the different classes with Iterator in their name, including some not covered in this chapter.
Despite all these useful iterators, you're bound to want additional ones. Fortunately, iterators don't have to be coded in C. You can easily code iterators in PHP, for looping through LDAP or IMAP listings, or even cycling through results fetched from Amazon.com using REST.
You can also embed an iterator inside a class using aggregation. When the object is iterated inside a foreach loop, the embedded iterator is used, effectively turning your objects into iterators.
For example, you can iterate over SQLite query results without explicitly fetching each row:
$db = new SQLiteDatabase($database);
foreach($db->query($sql) as $row) {
// operate on $row
}The SQLiteResult class has a built-in iterator that calls the object's fetch( ) method during iteration, and you can do the same for your own PHP classes. Normally, when you iterate over an object with foreach, PHP cycles through the object's properties. In PHP 5, you can override this behavior and make PHP loop over whatever you decide.
This chapter starts with iteration basics, by first showing how to iterate through a directory using PHP 4 and then comparing that to PHP 5's DirectoryIterator iterator. Afterward, there's a version of DirectoryIterator written in PHP.
The next iterator discussed in this chapter simplifies an example from earlier in the book: handling the results of MySQL multi-queries. Without an iterator, navigating through multi-query results is tricky, but this challenge is made simple using MySQLiQueryIterator.
Iterators don't have to work alone. You can combine them to filter and limit results. SPL has meta-iterators, or iterators that need to be fed another iterator to be useful.
For instance, using the FilterIterator in conjunction with a DirectoryIterator allows you to eliminate files that don't end in .html from your directory output.
Then there's the LimitIterator, which allows you to "page" through an iterator's results, using the same syntax as the SQL LIMIT clause. Combining it with the SimpleXMLIterator lets you redeploy your database logic onto XML documents.
After regular iterators, the chapter moves on to recursive iterators. Normal iterators only work for a single list of items, but it's quite common to have lists within lists. Directories contain files, but they can also contain other directories. To recurse through multiple levels, you need to upgrade your iterator to handle this complexity.
SPL's RecursiveDirectoryIterator class solves this task. Again, this iterator is recreated in PHP, to demonstrate the additional methods.
Once that's complete, there's a slight shift as this chapter moves back to traditional array and object iteration. PHP 5 brings a few changes to these old favorites to account for property access restrictions.
The chapter then shows how to implement the IteratorAggregate method. This lets a class return a custom iterator that you control, instead of using PHP's default behavior.
Finally, the last section lists all the SPL classes and interfaces, so you can get a bird's-eye view of the material and see what else SPL has to offer.
