The Singleton design pattern is a creational design pattern that restricts the instantiation of a class to one object. This means that only a single instance of a class can be created and accessed globally throughout the program.
In PHP, you can implement the Singleton pattern using the following code:
“`php
class Singleton {
private static $instance;
private function __construct() {
// private constructor to prevent creating new instances
}
public static function getInstance() {
if (self::$instance === null) {
self::$instance = new self();
}
return self::$instance;
}
public function doSomething() {
// method implementation
}
}
“`
In this example, the Singleton class has a private static property called `$instance`, which holds the single instance of the class. The class also has a private constructor, preventing the direct instantiation of the class from outside.
The `getInstance()` method is declared as `public static` and is responsible for creating or returning the single instance of the class. It checks if the `$instance` property is null. If it is null, it creates a new instance of the class and assigns it to the `$instance` property. It then returns the `$instance`.
The `doSomething()` method is an example method that can be called on the singleton instance.
To use the Singleton class, you would call the `getInstance()` method to get the singleton instance, and then call the methods on that instance:
“`php
$singleton = Singleton::getInstance();
$singleton->doSomething();
“`
This ensures that only one instance of the class is created and accessed throughout the program.