• Added support for copy to/from array/file for pdo_pgsql extension. (Denis Gasparin, Ilia)
• Changed namespaced classes so that the ctor can only be named __construct now. (Stas)
• Fixed bug #51590 (JSON_ERROR_UTF8 is undefined). (Felipe)
• Fixed bug #49576 (FILTER_VALIDATE_EMAIL filter needs updating) (Rasmus)
• Fixed bug #48361 (SplFileInfo::getPathInfo should return the parent dir). (Etienne)
• And well over a hundred other bug and security fixes

The change to constructors in namespaced classes has already been the subject of “why doesn’t this work” questions. With 5.3.3 you cannot define class constructors like below.

namespace Foo {
    class Bar {
        function Bar() {
            // constructing \Foo\Bar class
        }
    }
}

Instead, you need to be using the right and proper __construct method. Note that this only applies to namespaced classes, so old code can continue (if they like) using the class-name-based constructor. This really only affects the (few?) folks who might be making use of, or adapting their old code to use, namespaces yet still keeping the old style of naming the constructor method.

Go, play!

Happy birthday, PHP!

* See Announce: Personal Home Page Tools (PHP Tools) Options (8th June 1995)

Elsewhere

• 15 years of PHP from Johannes Schlüter

Intro to the glob function

To quote the succinct description on the PHP manual page for glob:

The glob() function searches for all the pathnames matching pattern according to the rules used by the libc glob() function, which is similar to the rules used by common shells.
http://php.net/glob

What’s in a pattern?

Most people who have already encountered glob know to make use of the * metacharacter to match some characters, and those digging a little deeper often discover that discrete alternatives can be globbed with braces (e.g. image.{gif,jpg,png}). However, there are more special characters and sequences that can be used to be more (or less, if we want) specific about what to find.

Aside: please do not make the mistake of thinking that glob patterns are regular expressions, they’re just not. If you do want to use regular expressions to find paths/files then you are invited to use SPL’s RegexIterator, which allows filtering of an Iterator based on a PCRE regex, in conjunction with a DirectoryIterator or FilesystemIterator (there are recursive flavours of the Regex- and DirectoryIterator if you need to delve into folders). For those SPL-ly inclined, also note the GlobIterator which combines the goodness of globbing with iteration. If that made entirely no sense, please read on! Globs are much less verbose…

So, here are the special doohickeys (technical term!) that we can use with glob:

* (an asterisk)

Matches zero of more characters.

?

Matches exactly any one character.

[...]

Matches one character from a group. A group can be a list of characters, e.g. [afkp], or a range of characters, e.g. [a-g] which is the same as [abcdefg].

[!...]

Matches any single character not in the group. [!a-zA-Z0-9] matches any character that is not alphanumeric.

\

Escapes the next character. For special characters, this causes them to not be treated as special. For example, \[ matches a literal [. If flags includes GLOB_NOESCAPE, this quoting is disabled and \ is handled as a simple character.

Globbingly good glob examples

Here are a few examples of what globs might look like alongside a brief description of the intended behaviour: if you have any suggestions please do make them in the comments as I'm running short on inspiration!

Well there we go, I’ve said what I came here to say so all that remains to be done is give some link love to those two recent articles that prompted me to dust off this draft and click the “publish” button.

With thanks

1. php|architect’s Putting glob() to the test focuses on execution times of glob and other techniques of getting a list of files.
2. Marcus Schumann’s Loop Through Folders with PHP’s Glob() article on Nettuts+ gives a brief introduction for those who might not have been introduced to glob.

The (currently undocumentednow documented³) DOMXPath::registerPHPFunctions method is available as of PHP 5.3.0 (it was added to the code base back in December 2006) and allows the use of PHP functions (and static methods) within XPath queries to complement the normal set of XPath functions².

Description

void DOMXPath::registerPHPFunctions ([ string|array $restrict] )

Enables the use of PHP functions as XPath functions.

Parameters

restrict

Use this parameter to only allow certain functions to be called from XPath; it can be either a string (a function name) or an array of function names.

Return Values

No value is returned.

Examples

Note: The following examples load a sample XML document called book.xml with the following contents:

<?xml version="1.0" encoding="UTF-8"?>
<books>
    <book>
        <title>PHP Basics</title>
        <author>Jim Smith</author>
        <author>Jane Smith</author>
    </book>
    <book>
        <title>PHP Secrets</title>
        <author>Jenny Smythe</author>
    </book>
    <book>
    	<title>XML basics</title>
    	<author>Joe Black</author>
    </book>
</books>

Example #1: Call a PHP function in XPath with php:functionString

This example demonstrates the basic use of DOMXPath::registerPHPFunctions by replicating the substring XPath function. The first thing that needs to be done is to register the php namespace with the associated URI http://php.net/xpath. Don’t question it, it just needs to be done!

Next, we call DOMXPath::registerPHPFunctions on our object. If no arguments are used, as in this example, then the range of functions allowed to be called is not restricted—you can call any⁴ function from XPath. I would always advise restricting the functions which can be called, see example 2.

Within our XPath query, we use php:functionString which allows us to name a function and provide some parameters (or indeed, no parameters) to be passed to that function. There are two flavours which can be used here: php:functionString which passes an XML node/attribute as a string and php:function (see example 3) which passes an array of XML node/attribute objects (in DOMElement / DOMAttr / etc. form) to the function . In this example the PHP function substr is called, passing along the book’s title (in string form), an offset of 0 and length of 3. This returns the first 3 characters of the book’s title which is then compared to the string PHP in order to filter our list of books down to those having titles starting with PHP.

<?php
$dom = new DOMDocument;
$dom->load('book.xml');
 
$xpath = new DOMXPath($dom);
 
// Register the php: namespace (required)
$xpath->registerNamespace("php", "http://php.net/xpath");
 
// Register PHP functions (no restrictions)
$xpath->registerPHPFunctions();
 
// Call substr function on the book title
$nodes = $xpath->query('//book[php:functionString("substr", title, 0, 3) = "PHP"]');
 
echo "Found {$nodes->length} books starting with 'PHP':\n";
foreach ($nodes as $node) {
	$title  = $node->getElementsByTagName("title")->item(0)->nodeValue;
	$author = $node->getElementsByTagName("author")->item(0)->nodeValue;
	echo "$title by $author\n";
}
?>

The example will output something like:

Found 2 books starting with 'PHP':
PHP Basics by Jim Smith
PHP Secrets by Jenny Smythe

Example #2: Restricting the functions available to XPath

To restrict the functions made available to XPath, provide either a string containing the name of the single function that you wish to allow or an array of strings containing function names as the restrict parameter (note: static methods can also be used, e.g. “Classname::method“). If functions were added with restrict and a function is called in XPath which is not one of them, an E_WARNING will be raised stating Not allowed to call handler ‘function()’ (where function is the name of the function that cannot be called).

<?php
$dom = new DOMDocument;
$dom->load('book.xml');
 
$xpath = new DOMXPath($dom);
 
// Register the php: namespace (required)
$xpath->registerNamespace("php", "http://php.net/xpath");
 
// Register PHP functions (no restrictions)
$xpath->registerPHPFunctions("strtoupper");
 
// Get first book's title in uppercase
$title = $xpath->evaluate('php:functionString("strtoupper", //book[1]/title)');
echo $title;
 
// Try a function not in our restrictions list
$fail = $xpath->evaluate('php:functionString("strtolower", //book[1]/title)');
 
?>

The example will output something like:

PHP BASICS<br />
<b>Warning</b>:  DOMXPath::evaluate() [<a href='domxpath.evaluate'>domxpath.evaluate</a>]: Not allowed to call handler 'strtolower()'. in <b>example2.php</b> on line <b>18</b><br />

Example #3: Passing DOM objects using php:function

Up to now, the examples have both used php:functionString. As mentioned above, instead of passing a string value to the PHP function it is possible to pass along an array of DOM* objects to manipulate them as you please by using php:function.

<?php
$dom = new DOMDocument;
$dom->load('book.xml');
 
$xpath = new DOMXPath($dom);
 
// Register the php: namespace (required)
$xpath->registerNamespace("php", "http://php.net/xpath");
 
// Register PHP functions (no restrictions)
$xpath->registerPHPFunctions("example3");
 
function example3($nodes) {
    // Return true if more than one author
    return count($nodes) > 1;
}
// Filter books with multiple authors
$books = $xpath->query('//book[php:function("example3", author)]');
 
echo "Books with multiple authors:\n";
foreach ($books as $book) {
    echo $book->getElementsByTagName("title")->item(0)->nodeValue . "\n";
}
?>

The example will output something like:

Books with multiple authors:
PHP Basics

Summary

Just to quickly summarise everything, here is a quick run-down. In PHP, make sure to register the php namespace (with the URI http://php.net/xpath) and then register your PHP functions (whether core, extensions or user-defined) or static methods with DOMXPath::registerPHPFunctions. In XPath, use php:functionString or php:function to call the PHP function.

If you have made use of this feature, or want to know more, then do feel free to comment. Thanks for reading.

Footnotes

1. http://php.net/dom
2. http://schlitt.info/opensource/blog/0704_xpath.html
3. The documentation page, when it gets written, will beis available at http://php.net/domxpath.registerphpfunctions
4. In truth, some functions are not suitable such as those that return non-scalar values (and cannot be cast to one) which XPath will not understand.

On the plus side, for those who have yet to take the plunge into using PHP 5.3, this iterator has been part of the core of PHP as of 5.1.0 so there is a much greater chance of actually being able to use it right now. Bear in mind that the SPL is supposed to work together with its component parts so if iterators are a foreign concept, some of this post might be a little unclear but it is not the purpose of this post to outline iterators in PHP.

As eluded to above, the InfiniteIterator comes in useful when you have an existing Iterator (anything that implements that interface; a directory listing (DirectoryIterator), a file (SplFileObject), an array (with ArrayIterator), and so on) and wish to iterate over its contents again and again.

An InfiniteIterator Example

Here is a basic example that I wrote for the documentation. Note that a LimitIterator is used to restrict the values which are iterated over (otherwise the loop would go on forever!).

<?php
$arrayit  = new ArrayIterator(array('cat','dog'));
$infinite = new InfiniteIterator($arrayit);
$limit    = new LimitIterator($infinite, 0, 7);
foreach($limit as $value)
{
    echo "$value\n";
}
?>

This example outputs something along the lines of:

cat
dog
cat
dog
cat
dog
cat

Can you think of any more useful instances where the InfiniteIterator might come in useful?

Here’s the summary

• Just because it’s not the latest and greatest version, it doesn’t mean it’s not good
• Just because you don’t understand something, it doesn’t mean you shouldn’t embrace it
• There’s nothing stronger than a bond between those who care
• It takes all kinds to make the ‘verse go ’round
• Use only what you need
• A good team is nothing without good leaders

Anonymous Functions

Put plainly, an anonymous function is a function without a name. That’s all, there’s nothing magic or particularly technical about it. There are a few ways to create an anonymous function in PHP; up until PHP 5.3 came around the usual way was to use create_function (see fig. 1) which takes a couple of arguments as strings and spits out a function, in PHP 5.3 we’re allowed to create anonymous functions looking much more like normal function definitions (see fig. 2).

Fig. 1: Anonymous function with create_function

<?php
$square = create_function('$x', 'return $x*$x;');
echo $square(2); // 4
?>

Fig 2: Anonymous function as of PHP 5.3

<?php
$square = function($x) {
    return $x * $x;
};
echo $square(2); // 4
?>

I hope you’ll agree that the latter is a much nicer way (visually) of defining an anonymous function, quite apart from the more logical and performance-related (see comment #4) aspects of using it.

Closures

A closure is a (anonymous) function that is aware of its context. For all intents and purposes, think of them being anonymous functions which know about some variables which weren’t defined within them. In geeky language, they are functions which close over (hence “closure”) free variables, the latter being variables which are not local nor arguments to the function. It is easier to see with an example, I think.

Without Closure

Lets say that we need a function to add three to a number (overly basic, I know). That’s easy.

<?php
$add_3 = function($x) {
    return $x + 3;
};
echo $add_3(10); // 13
?>

Now if we wanted another function to behave similarly but instead it should add 4 to the supplied number, we could just as easily create a new anonymous function to do the job.

<?php
$add_4 = function($x) {
    return $x + 4;
};
echo $add_4(10); // 14
?>

If, however, you wanted to do that for a series of different additions then things could get very repetitive, very quickly! If only we could dynamically create an anonymous function to do what we wanted: enter the closure.

With Closure

We can define an anonymous function (it needn’t be anonymous but lets keep on theme) which returns anonymous function based on arguments supplied to it. Remember our definition of a closure above, specifically making use of ‘free’ variables, that is what our $value_to_add is in the example below.

<?php
$add = function($value_to_add) {
    return function ($x) use ($value_to_add) {
        return $x + $value_to_add;
    };
};
 
$add_3 = $add(3);
$add_4 = $add(4);
 
echo $add_3(10); // 13
echo $add_4(10); // 14
?>

A more practical example

As fun as silly adding examples are, there will be undoubtedly someone who has been reading everything above (good job getting this far!) and cannot see a practical use for all of this. Since le Tour de France is on, lets have a play on words and have an example on cycling (over a series of values).

Cycling with Closures

<?php
// Cycle factory: takes a series of arguments
// for the closure to cycle over.
function cycle() {
    $items = func_get_args();
    // Create closure using the supplied list of arguments
    return function() use (&$items) {
        // Get current item
        $current = each($items);
        // Rewind if at the end of the list
        if ($current === FALSE) {
            reset($items);
            $current = each($items);
        }
        // Return the current item
        return $current['value'];
    };
}
 
// Create our list of CSS classes to cycle over
$class = cycle('odd', 'even');
// List of adjectives, why not
$taste = cycle('vile', 'yummy', 'delicious');
 
// Our list of items to be formatted into a pretty HTML list
$items = array('apple', 'banana', 'cherry', 'date', 'elderberry', 'figs');
 
?>
<ul>
<?php foreach ($items as $item) : ?>
	<li class="<?php echo $class() ?>"><?php echo $item ?> are <?php echo $taste() ?></li>
<?php endforeach ?>
</ul>

That example would provide the following output:

<ul>
	<li class="odd">apples are vile</li>
	<li class="even">bananas are yummy</li>
	<li class="odd">cherries are delicious</li>
	<li class="even">dates are vile</li>
	<li class="odd">elderberries are yummy</li>
	<li class="even">figs are delicious</li>
</ul>

Well, it’s a little bit more practical anyway! Have you been playing with closures and/or anonymous functions too?

Go download and play with the new features available such as namespaces, LSB, anonymous functions and closures along with many more bug fixes, additions and improvements.

My favourite addition at the moment is the improvements made to the DateTime extension with new classes such as DatePeriod (for iterating over dates/times) and DateInterval and additions to the DateTime class such as DateTime::createFromFormat and DateTime::add (and sub).

The anonymous functions will also be very useful where one might previously use create_function (or a normal non-anonymous function) in particular for callbacks to other functions/methods.

<?php
echo preg_replace_callback('/[A-Z]/', function ($match) {
    return str_rot13($match[0]);
}, 'Uello Jorld!');
?>

So, download it and have an explore.

The problem is that the most common way of parsing strings into a more usable format (Unix timestamp) is to use strtotime(). However, this function does not like dd/mm/yyyy formatted strings and will at best parse the string as mm/dd/yyyy and at worst return FALSE (if it could not parse the date string as mm/dd/yyyy).

Quick workaround

One quick thing that works, and I’ve advocated in forum posts before, is to provide a date string in the format dd-mm-yyyy. Note that the date parts are in the same order, just the separator has changed from a forward slash (/) to a hyphen (-). A date formatted in this way will be happily parsed by strtotime. For example:

date_default_timezone_set('UTC');
$date = '14/06/2009';                 // dd/mm/yyyy
$date = str_replace('/', '-', $date); // dd-mm-yyyy
echo date('r', strtotime($date));
// Sun, 14 Jun 2009 00:00:00 +0000

Using DateTime

As of PHP 5.2.0 (and experimentally in 5.1.x) we have also had the ability to play with dates and times using the built-in DateTime extension (Aside: the date_default_timezone_set function used above comes from this extension). To repeat the above but in DateTime form:

$date = '14/06/2009';                 // dd/mm/yyyy
$date = str_replace('/', '-', $date); // dd-mm-yyyy
$date = new DateTime($date, new DateTimeZone('UTC'));
echo $date->format('r');
// Sun, 14 Jun 2009 00:00:00 +0000

Help Coming!

I’m sure that you’ll agree, the above is hardly a perfect solution to the problem (but is a sufficient workaround for now). However help is at hand. As of PHP 5.3.0 we will be able to make use of a new static method on the DateTime class. This method is DateTime::createFromFormat which requires two arguments; a string specifying the format which the date string has (as used by the date function), and the date string itself (there is also a third, optional, argument for the timezone to be used).

An example of its use, analogous to the snippets above, would be:

$date = DateTime::createFromFormat('d/m/Y', '14/06/2009', new DateTimeZone('UTC'));
$date->setTime(0,0,0);
echo $date->format('r');
// Sun, 14 Jun 2009 00:00:00 +0000

Aside: For my installation (PHP 5.3.0RC3) this method does not parse the date string as midnight, as the other code snippets do, but will use current time! This is why the setTime method (available as of 5.2.0) is used, to force the time to be midnight (arguments are hour, minute, second). Edit: One could instead use the ! within the format string like !d/m/Y, since the time portion is missing it will substitute the Unix epoch’s time (midnight) in its place. See the manual for details of !.

Just to wrap things up, the DateTime::createFromFormat should help considerably towards parsing previously ambiguous date strings into forms that can be manipulated and at least will get around the string manipulation being offered as a solution right now. If you’re still stuck playing around with the date string, at least you know that dd-mm-yyyy will be parsed as you want.