In fact, the singleton mode, to put it bluntly, means that a class can only be instantiated once. But how do we make a fuss about this instantiation? In fact, a breakthrough is the magic method __construct(). This method means that if the class is instantiated, this method will be automatically executed. Then if I make this method protected or private, what will be the effect?
<?php
class test{
protected function __construct(){
}
}
$test = new test();
?>Then execute the following, this situation will occur.
<img data-rawheight="125" data-rawwidth="994" src="https://img.php.cn/upload/article/000/054 /025/a79c550120d3e119df603c5755b0f293-0.jpg" class="origin_image zh-lightbox-thumb" width="994" src="https://pic4.zhimg.com/3a977167d4bb4083db5218628d34 e0d3_r.jpg"> 
In this case, it cannot be instantiated. This ensures that it cannot be instantiated by anyone.
But in this case, how should we implement instantiation. That’s it:
<?phpclass test{
protected function __construct(){
}
public static function getInstance(){
$_test = new test();
return $_test;
}}$test = test::getInstance();var_dump($test);?> Such words. An example will appear. Let’s take a look:
<img data-rawheight="50" data-rawwidth="152" src="https://img.php.cn/upload/article/000/ 054/025/a79c550120d3e119df603c5755b0f293-1.jpg" class="content_image" width="152">
But after saying so much, I still haven’t gotten to the point. Here comes the key point, as long as we use another keyword (static). Dang Dang Dang Dang:
<?php
class test{
protected function __construct(){
}
public static function getInstance(){
static $_test;
if (empty($_test)) {
$_test = new test();
}
return $_test;
}
}
$test1 = test::getInstance();
$test2 = test::getInstance();
$test3 = test::getInstance();
var_dump($test1,$test2,$test3);
echo $test1 == $test2 ? 'true' : 'false';
echo "<br>";
echo $test2 == $test3 ? 'true' : 'false';
echo "<br>";
echo $test1 == $test3 ? 'true' : 'false';
?>Look at the result:
<img data-rawheight="160" data-rawwidth= "133" src="https://img.php.cn/upload/article/000/054/025/a79c550120d3e119df603c5755b0f293-2.jpg" class="content_image" width="133"& gt;
In this way, the effect of PHP singleton can be achieved.
For a singleton, it is best to use only this one class instead of multiple classes.
Let’s use an analogy. For example, there is now a config class, which mainly stores the configuration information of this project. If this class can be instantiated multiple times, then if the configuration is modified while the code is running, how do you know which configuration class the modification was made in. At this time, using the singleton mode will avoid the situation. All changes to the configuration file will be modified based on the instance of this class. It will not appear that due to the instantiation of multiple classes, the operation will not be updated in real time for changes in operations. Moreover, instantiating multiple class libraries will occupy a lot of memory, so they are only instantiated once. Isn’t there a lot of benefits?
Other insights:
Private the clone too
class test{
private static $instance;
private function __construct(){
}
private function __clone(){
}
public static function getInstance(){
if (! self::$instance instanceof self ) {
self::$instance = new self();
}
return self::$instance;
}
}More intuitive method:
Click to open the link
/*
单例设计模式 (单态)
定义: 一个类 只能允许有 一个对象存在.
1.不让进: 使类不能被实例化
2.留后门: 设置静态方法
3.给对象: 在静态方法里实例化该类
4.判初夜: 判断是否是 第一次产生该类的对象
5.设静态: 静态方法里 要使用静态属性
*/
/*//1.不让进: 使类不能被实例化-----------------
class Test
{
// 设置 一个封装的构造方法
private function __construct()
{
//占位, 我就是不让你NEW我~~~
}
}*/
/*//2.留后门: 设置静态方法--------------------
class Test
{
// 设置 一个封装的构造方法
private function __construct()
{
//占位, 我就是不让你NEW我~~~
}
//后门
public static function getObject()
{
echo "啊,我是后门,进吧!<br>";
}
}*/
/*//3.给对象: 在静态方法里实例化该类------------------
class Test
{
// 设置 一个封装的构造方法
private function __construct()
{
//占位, 我就是不让你NEW我~~~
}
//后门
public static function getObject()
{
echo "啊,我是后门,进吧!<br>";
return new self();//实例化一个对象给你
}
}*/
/*//4.判初夜: 判断是否是 第一次产生该类的对象------------------
class Test
{
private $obj = null;//属性值为对象,默认为null
// 设置 一个封装的构造方法
private function __construct()
{
//占位, 我就是不让你NEW我~~~
}
//后门
public static function getObject()
{
echo "啊,我是后门,进吧!<br>";
if ($this->obj === null) {
$this->obj = new self();//实例化一个对象
}
//返回的属性 其实就是本对象
return $this->obj;
}
}*/
//5.设静态: 静态方法里 要使用静态属性------------------
class Test
{
private static $obj = null;//属性值为对象,默认为null
// 设置 一个封装的构造方法
private function __construct()
{
//占位, 我就是不让你NEW我~~~
}
//后门
public static function getObject()
{
echo "啊,我是后门,进吧!<br>";
if (self::$obj === null) {
self::$obj = new self();//实例化一个对象
}
//返回的属性 其实就是本对象
return self::$obj;
}
}
/*Test::getObject();//使用静态方法访问该类里的方法
exit;*/
$t1 = Test::getObject();
$t2 = Test::getObject();
$t3 = Test::getObject();
$t4 = Test::getObject();
$t5 = Test::getObject();
$t6 = Test::getObject();
$t7 = Test::getObject();
$t8 = Test::getObject();
//判断 两个对象 是否是同一个对象
if ($t1 === $t6) {
echo "哦, Yes! 是同一个实例<br>";
} else {
echo "哦, No! 不是同一个实例<br>";
}Related recommendations:
Analysis of the advantages of PHP singleton mode
Detailed demo explanation of PHP singleton mode
Simple usage sharing of PHP singleton mode
The above is the detailed content of Detailed explanation of php singleton mode. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
