With the release of PHP 5.3 comes the functionality “late static binding”, a feature which I’ve been impatient to see for quite some time! This is something a lot of developers have been puzzled by in earlier versions of PHP 5, probably without being aware it had a name. In PHP 5.3 there is functionality for dealing with this situation so here’s an outline the problem and then a look at how to avoid it with PHP 5.3.
The issue arises because of the way PHP classes refer to themselves. Keywords like self are resolved at compile time, which means that where classes inherit from one another, self will always relate to the class where it is mentioned and not the class which is inheriting it. Many class hierarchies will have common functionality across classes but which need some form of “which class is this?” awareness, either to access the class name or a variable declared in the class so that a method declared in the parent can be used in all inheriting classes. Without late static binding, this will always resolve to the declaring class, leaving developers the choice between copy/pasting the same function into every class that needs it or turning their static method into a dynamic one, since $this resolves as expected.
It’s perhaps clearer to illustrate the problem by showing an example. Here I have a base class Record, which all my other classes will extend from (in the tradition of these things, its an over-simplified and not-terribly-useful example but I think it shows the point):
class Record {
protected static $tableName = 'base';
public static function getTableName() {
return self::$tableName;
}
}
So, I’m ready to write my first useful class, which will be my user class – it will have its own variables but can inherit the function since they’re identical.
class User extends Record {
protected static $tableName = 'users';
}
So if we call the getTableName method against the User class – what would you expect the output to be?
User::getTableName(); // returns "base"
That isn’t what I expected when I first ran into this scenario. This is a pretty common thing to want to do, I’ve seen people have this problem when implementing active record patterns, when creating re-usable form widgets with their own templates, and in countless other applications. With PHP 5.3, the static keyword has been implemented to allow us to get the value of the class the code is actually executing inside rather than where it was inherited from. We simply replace the “self” in our Record class with “static”:
class Record {
protected static $tableName = 'base';
public static function getTableName() {
return static::$tableName;
}
}
This keyword evaluates differently and has awareness of its calling context – so if we repeat our call to the getTableName method against the User class:
User::getTableName(); // returns "users"
That’s better :)
This feature doesn’t make this problem go away – the self keyword still resolves to parent so as PHP developers we will still see this slightly unexpected behaviour where the parent values are returned. However there is now a solution to it in the shape of the new static keyword. Its a feature I’m delighted to see included and I’m sure it’ll be helpful in a wide range of applications!
Does this help you? Have you run into this behaviour before? And how did you solve it? Leave a comment!
