Singleton Pattern and its implementation in PHP

The Singleton pattern is a creational design pattern that ensures a class has only one instance and provides a global point of access to that instance. It is commonly used when there is a need to have a single instance of a class throughout the application and to control access to that instance. In PHP, the Singleton pattern can be implemented using a private constructor, a static method for accessing the instance, and a static variable to store the single instance.

Example on how we  implement this in PHP:

class Singleton {
    private static $instance;

    // Private constructor to prevent direct instantiation.
    private function __construct() {
        // Initialization code.
    }

    // Static method to access the single instance.
    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    // Example method of the singleton instance.
    public function doSomething() {
        echo "Doing something.<br>";
    }
}

// Usage example:
$singleton1 = Singleton::getInstance();
$singleton1->doSomething();  // Output: Doing something.

$singleton2 = Singleton::getInstance();
$singleton2->doSomething();  // Output: Doing something.

var_dump($singleton1 === $singleton2);  // Output: bool(true)

In this example, the Singleton class has a private constructor to prevent direct instantiation. The getInstance() method is the static method that provides access to the single instance. It checks if the instance exists, and if not, it creates a new instance and stores it in the static variable self::$instance. Subsequent calls to getInstance() will return the existing instance.

The Singleton class also includes an example method doSomething() to demonstrate the functionality of the singleton instance.

In the usage example, we obtain two instances of the Singleton class using the getInstance() method. Both instances are the same, as evidenced by the var_dump() statement, which outputs true since they are referring to the same object.

The Singleton pattern provides global access to a single instance, which can be useful for managing resources that should be shared across the application. However, it can also introduce tight coupling and make testing more difficult. Therefore, it's important to carefully consider the use cases before applying the Singleton pattern. In my opinion, you should avoid such implementation and go for Dependency Injection Pattern.