Why namespaces? There are thousands of plugins out there and chances are rising that someone writes a class or function with the same name as you do. Once a user activates both plugins, PHP doesn’t know which function to use and exits peacefully. Use namespaces to prevent this from happening.

There are four ways to namespace WordPress plugins.

1. You don’t care — which is never a good idea. But you do because you’re reading this post. Awesome!
2. Prepending all your function names with prefixes
3. Use a class as a namespace and nest all your functions in that class
4. Use the PHP 5.3 language feature “namespace”

Prefixing

Prefixing is the quick and dirty approach. Your plugin is called The Troublesome But Cool Widget, so your prefix might be ttbcw. Every function you write starts with that prefix, so instead of init, your function will be named ttbcw_init.

It’s an acceptable solution for small plugins where you don’t have to write more than a handful of functions. However, it’s quite ugly and becomes increasingly unhandy the more complex your plugin grows.

Class as Namespace

That’s what you’ll find quite often if you look into popular plugins today. Many developers avoid real namespaces as they require PHP 5.3, which is still not widely adopted by hosters. Have a look at the following example.

<?php
class TheTroublesomeButCoolWidget {
	public function __construct() {
		$this->register_scripts();
		$this->register_shortcode();
		$this->register_setup_hooks();
	}
	private function register_scripts() { /* ... */ }
	private function register_shortcode() { /* ... */ }
	private function register_setup_hooks() { /* ... */ }
}

new TheTroublesomeButCoolWidget();

Now you can reuse function names in all of your plugins — nice! By the way, it is advisable to implement the singleton pattern to avoid the possibility of initializing more than one instance of that class by accident. But that is outside the scope of this article. I’ll put a reference link into the resources section though.

Unfortunaltely, there is one major caveat: Splitting the plugin among multiple files is hard. Namespacing via classes encourages implementing all functionality in a single class and before you know your file has grown to a four digit number of lines of code. Let alone separation of concerns.

All in all, it’s an okay-ish solution for medium sized plugins — but still ugly from a software architecture perspective.

Real Namespaces

Recently, I have been talking about PHP 5.3 language features a lot. There’s always the question whether to use them or not. If you’re inclined to read more about it I can point you to some articles. Have a look at the comment sections, too!

• PHP 5.3 in WordPress Plugins
• Rethinking Hook Declaration

Now, let’s assume we have agreed upon using 5.3 is not evil. At this point — let’s be honest — there’s no reason to use one of the solutions explained above. Native PHP namespaces are superior to all of them.

namespace TheTroublesomeButCoolWidget;

Simple, yet effective. You can declare any function names you like within this file. Nice bonus compared to class namespacing: Less indentation All functions may start at the beginning of the line.

Furthermore, you can start to divide your code into logical groups by nesting namespaces.

<?php
namespace TheTroublesomeButCoolWidget;
/* basic stuff */
namespace TheTroublesomeButCoolWidget\Settings;
/* code for the settings page */
namespace TheTroublesomeButCoolWidget\Lib;
/* utility functions */

And so on. You start by developing in a single file and can refactor out chunks of code once they grow large easily. Developer heaven :)

Summary

If you have decided to go for PHP 5.3, use real namespaces. Now. There is no reason not to.

Otherwise choose between prefixing and class namespacing. I recommend to only use prefixing for very simple plugins. Class namespacing is an acceptable choice for medium to complex plugins but you have to be creative when it comes to distributing code among multiple files.

Resources

• PHP Singletons via get_class
• PHP Namespaces

best practice namespace PHP 5.3