3 Ways to Access a Namespaced PHP Class
Take this example (in a file called namespaced-class.php)
namespace Christmas\DaysOf;
class PartridgeInAPearTree{
}
Now we have a few ways to access that class.
Refer Namespace and Class Name
The simplest way to access a class inside a namespace is simply to prefix the classname with its namespace(s):
include 'namespaced-class.php';
$bird1 = new Christmas\DaysOf\PartridgeInAPearTree();
var_dump($bird1);
You can use this anywhere in your code.
Import the Namespace
In PHP we can import namespaces using the use keyword, and then just use the last part of the name in place of the namespace. In my contrived Christmas-related example, we’d end up with something that looks like this:
include 'namespaced-class.php';
use Christmas\DaysOf;
$bird2 = new DaysOf\PartridgeInAPearTree();
var_dump($bird2);
This example works well because it saves us from typing anything but the last element of a potentially quite long-winded path.
Alias the Namespace and/or Class
We can alias just the namespace, as shown above, or right down to the class name, using the use keyword. Optionally we can also rename what we’d like to call it, rather than the final element in the path, by using the as keyword.
include 'namespaced-class.php';
use Christmas\DaysOf\PartridgeInAPearTree as Bird;
$bird3 = new Bird();
var_dump($bird3);
Even better, we can give a “nickname” to our namespace, either to avoid clashes or just to give us something more memorable or descriptive to use within the class. This will also be a great trick to use when namespace-using applications become legacy and we have to handle renaming of namespaces.
So Many Options
All of the above examples give a debug output of the same class; the class that was declared in the opening example file and included elsewhere. One thing I noted which was unfamiliar is that you must declare a namespace as the first thing in a file, and that the namespace is implicitly ended at the end of the file.
Are you using namespaces in your applications? How have you implemented them? I’m interested to hear how others are applying these techniques inside their architectures, please share!
One note on “Refer Namespace and Class Name”: if you have declared a namespace for the current file, you will need to refer to the namespaced class by prefixing it with a namespace separator — this ensures that the resolution is from the global namespace, and not relative to the current namespace. So, for example:
[geshi lang=php]
namespace Foo;
include ‘namespaced-class.php’;
$bird1 = new \Christmas\DaysOf\PartridgeInAPearTree();
[/geshi]
Note the “\” preceding “Christmas” — that’s what tells PHP to start at the global namespace.
Thanks Matthew you saved me a comment.
Well… you got my point ;)
I’m using namespaces and am loving them. However there are still a few things I don’t like in how they’re implemented.
My most recent discovery is about callbacks. Simply speaking, you can’t use aliased classname in a callback. You need to pass a fully qualified name.
Not just callbacks, actually. Anytime you use a string to refer to a namespaced class — for instance, “new $className;”, or “$obj instanceof $classname” — you need to use a fully-qualified classname (though without the leading namespace separator).
I’ve just ported the new features of php 5.3 in my own framework.
Especally the autoloading is very simple when you are using the namespace feature. If you create the directory structure analog to the namespace you don’t have to search the class file in your directories. I don’t like long class names which represent the directory path to the class file. With namespaces you have short class names like i loved in java.
I missed in your example the following notation without alias:
use your\namespace\ExampleClass;
$obj = new ExampleClass();
Oh yes. Autoloading is really cool now. If ony they decided not to cripple spl_autoload() by making it load lowercase filenames only.
Unlikely. spl_autoload’s purpose is to allow using multiple autoloader callbacks (which prevents issues of duplicate __autoload() definitions). Since callbacks are always user-defined, case sensitivity is up to the implementor.
I think you’re confusing spl_autoload() with spl_autoload_register().
spl_autoload_register(), as you said, allows you to put multiple callbacks into autoloading stack.
spl_autoload() is a default autoloader, that gets registered when you call spl_autoload_register() with no arguments.
It has many advantages and one flaw. It is compiled into PHP core, so it’s fast. It automatically takes into account registered autoload extensions. It works well with namespaces (including aliased classes). But, unfortunately, it only looks into files which names are lowercased version of class name. For someone, who like Simon above comes from Java background, having to keep your (usually capitalised) classes in lowercased files is something akin to blasphemy.
Or you can use the “pihipi” meta compiler and avoid the magic-quotes-2.0 namespace syntax altogether.
I love namespaces – thanks for a great post
Thanks to everyone who popped in and contributed to this, I think I learned as much from the comments as there was in the original post :)