The singleton pattern is defined as a design pattern that is used to restrict instantiation of a class to one object (or limit number of instances). This is a pretty straight forward concept and works well with many other OOP techniques including the factory pattern. The easiest implementation is to create a public static method within that class that instantiates a new instance.

Example

<?php
class DB_Connection
{
	private $_con = null;
 
    public static function getInstance()
    {
        static $instance=null;
        if ($instance === null)
            $instance = new DB_Connection();
        return $instance;
    }
 
    public function query($sql)
    {
    	// DO SOME CODE TO RUN A QUERY HERE
    }
 
    public function __destruct()
    {
    	$this->_con->close();
    }
 
    private function __construct()
    {
    	$this->_con = new DB::connect('connection_string');
    }
 
}
?>

You’re probably wondering why the class constructor is private. This seems odd as it’s impossible to create an object from outside the class, right? That’s the point. If we don’t limit the class instantiation, the singleton pattern is useless. The method getInstance() can create an object as it’s a member of that class.

How does the static method work?

The static method getInstance() declares a static variable called instance ($instance). The first time this method is called, the $instance variable’s value is null. We then check if the value is null — if it is, we create a new instance of DB_Connection — if it is not, we return the current instance.

Static variables work by declaring the static keyword, then continuing on with the normal variable initialization. The variable will maintain it’s assigned value (whether changed or not) throughout the life of the script.

The second time the getInstance() is called, the $instance variable contains the instance of DB_Connection, and we will return that value. Regardless of how many instances are created of this class, only one object is initialized.

Conclusion

As you can see, the singleton pattern certainly has it’s uses, albeit specific. Keeping the OOP design patterns in mind makes for a cleaner, easier to maintain code base for future developers picking up your projects.