Singleton pattern in PHP

Introduction

Not something realy new and not invented by myself, but it is something realy usefull and changed the way i see OOP for ever.
Singleton is one of the many OOP patterns out there, each one of them servers a purpose and Singleton solves a basic issue, having stuff available without carring around variables or using globals.

How it is done

Lets see a practical case that singleton pattern cames in handy. What we usualy do in the startup proccess of the code is to load configuration and various setting for our application. The common way to do it, is create a class which loads and hold them. Something like the next chunk of code
class Settings { private $mySettings = array(); public function __construct() { } public function getSetting($id) { return $this->mySettings[$id]; } public function setSetting($id, $v) { $this->mySettings[$id]=$v; } }
ok, nothing much. If you instanciate this one you have to carry around the variable to this instance or make it global. Let's make her Singleton.
class Settings { private $mySettings = array(); private static $instance; public function __construct() { } public function get($id) { return $this->mySettings[$id]; } public function set($id, $v) { $this->mySettings[$id]=$v; } public static function getInstance() { if ( empty( self::$instance ) ) { self::$instance = new Settings(); } return self::$instance; } }
First of all notice the static variable $instance. This one is static so it is accessible before the class is instantiated and it is common to all instances of the class, ofcource in the same session. This variable is used to hold a pointer to the instance of the class. Even if the initial pointer to the instance comes out of scope, the value of this variable is untached.
Then we have the "magic" method getInstance. That one is also static. Checkes if the static variable (notice self::) has value, this means if the class has been instanciated before, if not creates an instance of the class and makes self::$instance pointing to her. So, when we make the call Settings::getInstance() for first time creates a new object and every other time it returns that object.
To make you believe try the next one:
$o = Settings::getInstance(); $o->set("far", "away"); unset( $o ); $o = Settings::getInstance(); echo $o->get("far");
the result you will get is the unexpected "away".

Now lets make it a little bit more real.
class Settings { private $mySettings = array(); private static $instance; public function __construct() { } public function loadSettings($conf_file) { // some file reading to fill $mySettings array } public function get($id) { return $this->mySettings[$id]; } public function set($id, $v) { $this->mySettings[$id]=$v; } public static function getInstance() { if ( empty( self::$instance ) ) { self::$instance = new Settings(); } return self::$instance; } }
In the bootstrap of our application
$conf = Settings::getInstance(); $conf->loadSettings('myapp.ini');
Somewhere else, anywhere else in our application now we can access the settings loaded in the bootstrap like this
$o = Settings::getInstance(); echo $o->get("far");

Conclusion

Isnt it great! The OOP response to global variables!

I hope that even if i didnt make it clear how it works, that I made clear how useful it is.

License

This article, along with any associated source code and files, is licensed under The Intelliproject Open License (IPOL)

About the author