John Squibb
Fun with PHP 5.3
02 September, 2009
Version 5.3 has been out a little over two months, so it's nigh time I dug into into it! It's surprising that I've waited this long to get around to installing it, as it contains some tidbits that I have been eagerly awaiting since talk about PHP 6 began a couple years ago. In addition to the usual bug fixes, this version includes support for two features of particular interest to me: namespaces and variable static method calls.
Variable Static Method Calls
One of the biggest annoyances prior to 5.3, was that one couldn't call the static method of a class using a variable. The following code, for example, just plain would not work:
<?php
$variable::static_method();
It is a very small change, but it makes all the difference in the world when using factories, builders, and singletons. Consider the following animal classes:
<?php
class Cow
{
public static $name = 'Herbert';
public static function speak()
{
print 'moo';
}
}
class Pig
{
public static $name = 'Leon';
public static function speak()
{
print 'oink';
}
}
class Cat
{
public static $name = 'Oedipus';
public static function speak()
{
print 'Meow';
}
}
//animals!
$animals = array('Cow', 'Pig', 'Cat');
//show variable static function calls
foreach ($animals as $animal)
{
//make silly sounds
print $animal::$name . ':';
$animal::speak();
print "\n";
};
If you have ever used the singleton pattern, you know that the key to fetching object instances is to call the instance() or similarly named function statically. Prior to 5.3, it was impossible to dynamically call upon singletons without using trickery, such as the call_user_func or call_user_func_array methods. Now, it is very easy to simply use the syntax demonstrated above.
Another situation where the dynamic call proves useful is when trying to fetch the constants of a particular class. In the past, the developer was forced to instantiate the class, and then use a custom function to fetch the constant and return it, or worse yet, use Reflection methods to try and parse the constants from the class. As of 5.3, it's very easy to do the following:
<?php
class Cow
{
const NAME = 'Herbert';
}
$cow = 'Cow';
print $cow::NAME;
Namespaces
PHP has long needed support for namespaces, and even though the new implementation is a little weird, it is certainly better than nothing (for most of us). At first, I was a little put-off by the Backslash delimiter (\) used for namespaces, as it is a departure form the C-like syntax that PHP usually honors. After a few uses, however, I found the PHP implementation quite easy to use, and could really care less whether it irks the C zealots who already hate PHP for a million other reasons besides this one.
The following code sample contains some different examples to try out:
<?php
namespace Work;
class Computer
{
public static function power()
{
print "Boo. I don't want to work now.\n";
}
}
namespace Play;
class Computer
{
public static function power()
{
print "All right! Video games!\n";
}
}
//using sub namespace
namespace Work\Exciting;
class Computer
{
public static function power()
{
print "This Job Rocks!\n";
}
}
//Sample Usage Method #1
namespace Work;
Computer::power();
namespace Play;
Computer::power();
namespace Work\Exciting;
Computer::power();
//Sample Usage Method #2
\Work\Computer::power();
\Play\Computer::power();
\Work\Exciting\Computer::power();
In a real-world implementation, I would caution against placing multiple namespaces in the same file, but if you absolutely had to, you could use the bracket method to declare your namespaces in addition to methods outlined above. This only works if you place your namespaces in a separate file, with no additional code among them. Consider the following:
<?php
//another way to declare namespaces when using multiple namespaces in a file
namespace BracketSyntax
{
class Computer
{
public static function power()
{
print "I am in a different file!\n";
}
}
}
namespace BracketSyntax2
{
class Computer
{
public static function power()
{
print "I am in a different file too!\n";
}
}
}
If you placed the above code in a file named bracketed_ns.php, you could call the appropriate classes in the same fashion as the previous examples:
<?php
//Method #3
require('bracketed_ns.php');
\BracketSyntax\Computer::power();
\BracketSyntax2\Computer::power();
If you are interested in checking out additional changes in version 5.3, head on over to the php.net release announcement page for a full list of new features.
Suggested Reading
Essential PHP Security
by Chris Shifflet
Suggested Reading
PHP Design Patterns
by Aaron Saray
Suggested Reading
PHP Objects, Patterns, and Practice
by Matt Zandstra
Suggested Reading
PHP 6 and MySQL 5
by Larry Ullman
Tags: php 5.3, static, method, namespaces
Short URL: http://sqb.in/s2tq