Learn about the prototype pattern in PHP in one article

In the previous article " A brief discussion of the iterator pattern in PHP" we introduced the iterator pattern in PHP. This article will take you to understand the prototype pattern in PHP.

#Prototype mode is actually more vividly called clone mode. Its main behavior is to clone objects, but it also calls the cloned object the original prototype, so this pattern is named. To be honest, judging from how it is used, it feels more appropriate to call it clone mode.

Gof class diagram and explanation

GoF definition: Use prototype instances to specify the types of objects to be created, and create new objects by copying these prototypes

GoF class diagram:

##Code implementation:

abstract class Prototype
{
    public $v = 'clone' . PHP_EOL;

    public function __construct()
    {
        echo 'create' . PHP_EOL;
    }

    abstract public function __clone();
}

First of all, we define a prototype through simulation. Here we mainly simulate the __clone() method. In fact, this is a magic method that comes with PHP. We don’t need to define it at all. We only need to implement it in the prototype class. When you use the clone keyword externally to clone an object, you will directly enter this magic method. In this magic method we can process properties, especially some unique processing for reference properties. In this example, we only used a value type variable. The problem of reference types cannot be reflected. We will demonstrate the processing of reference type variables in a later example.

class ConcretePrototype1 extends Prototype
{
    public function __clone()
    {
    }
}

class ConcretePrototype2 extends Prototype
{
    public function __clone()
    {
    }
}

The prototype of the specific implementation of the simulation is actually the main implementation of the __clone() method. We will explain this later when we look at specific examples.

class Client
{
    public function operation()
    {
        $p1 = new ConcretePrototype1();
        $p2 = clone $p1;

        echo $p1->v;
        echo $p2->v;
    }
}

$c = new Client();
$c->operation();

The client uses clone to copy

p2 also has the same $v attribute.

The prototype mode seems to copy the same object, but please note that when copying, the __construct() method is not called, that is, when you run this code, create Only output once. This also brings out one of the biggest features of the prototype pattern-
• Reduce the overhead of creating objects.
Based on the above characteristics, we can quickly copy a large number of identical objects, such as when we want to stuff a large number of identical objects into an array.
If the copied objects are all value type attributes, we can modify them arbitrarily without affecting the prototype. If there are reference type variables, some processing needs to be done in the __clone() method. Otherwise, modifying the contents of the reference variables of the copied object will affect the contents of the prototype object.

How is our mobile operating system (you can also imagine the operating system of a PC) installed on the device? In fact, they are constantly copying and copying the original system. The example of Microsoft illustrates this problem very well. Microsoft was able to become an empire back then because it kept copying copies of the winodws operating system to CDs and then sold them to thousands of households (of course, there is nothing wrong with China here) . As for the Chinese market, a large number of experts have cracked Windows and copied this file continuously before installing it into our computers. This is true for the operating systems and software of various products such as mobile phones and smart devices. Unlimited copies of one development are the reason for huge profits in the software industry. After all, our system was developed on the basis of the Android native system by many engineers working day and night. Hurry up and copy it to the mobile phones that are about to be shipped! !

完整代码：https://link.juejin.cn/?target=https%3A%2F%2Fgithub.com%2Fzhangyue0503%2Fdesignpatterns-php%2Fblob%2Fmaster%2F08.prototype%2Fsource%2Fprototype.php

Example

Let’s talk about mobile phones again. This time we are developing a batch of customized phones based on the needs of different operators, that is, package phones. To be honest, there is no difference between these mobile phones. Most of them have the same configuration, but the carrier systems are different, and occasionally some models may have different CPUs and memory. At this time, we can use prototype mode to quickly copy and only modify some of the differences.

Prototype mode production mobile phone class diagram:

##

完整源码：https://link.juejin.cn/?target=https%3A%2F%2Fgithub.com%2Fzhangyue0503%2Fdesignpatterns-php%2Fblob%2Fmaster%2F08.prototype%2Fsource%2Fprototype-phone.php

<?php
interface ServiceProvicer
{
    public function getSystem();
}

class ChinaMobile implements ServiceProvicer
{
    public $system;
    public function getSystem(){
        return "中国移动" . $this->system;
    }
}
class ChinaUnicom implements ServiceProvicer
{
    public $system;
    public function getSystem(){
        return "中国联通" . $this->system;
    }
}

class Phone 
{
    public $service_province;
    public $cpu;
    public $rom;
}

class CMPhone extends Phone
{
    function __clone()
    {
        // $this->service_province = new ChinaMobile();
    }
}

class CUPhone extends Phone
{
    function __clone()
    {
        $this->service_province = new ChinaUnicom();
    }
}


$cmPhone = new CMPhone();
$cmPhone->cpu = "1.4G";
$cmPhone->rom = "64G";
$cmPhone->service_province = new ChinaMobile();
$cmPhone->service_province->system = &#39;TD-CDMA&#39;;
$cmPhone1 = clone $cmPhone;
$cmPhone1->service_province->system = &#39;TD-CDMA1&#39;;

var_dump($cmPhone);
var_dump($cmPhone1);
echo $cmPhone->service_province->getSystem();
echo $cmPhone1->service_province->getSystem();


$cuPhone = new CUPhone();
$cuPhone->cpu = "1.4G";
$cuPhone->rom = "64G";
$cuPhone->service_province = new ChinaUnicom();
$cuPhone->service_province->system = &#39;WCDMA&#39;;
$cuPhone1 = clone $cuPhone;
$cuPhone1->rom = "128G";
$cuPhone1->service_province->system = &#39;WCDMA1&#39;;

var_dump($cuPhone);
var_dump($cuPhone1);
echo $cuPhone->service_province->getSystem();
echo $cuPhone1->service_province->getSystem();

Description:

I printed a lot of things, but the main thing is to look at the mobile phone, that is, the __clone() method in CMPhone. We did not re-initialize a new object. At this time, the copied
• cmPhone contains the same object. Yes, this is a reference duplication problem. The reference just copies the address of the reference, they point to the same object. when

  The attributes in the service_province object in cmPhone have also changed.

• In CUPhone, we created a new service_province object. This time the value of the referenced object in

  cuPhone outside.

• The most important thing in prototype mode is to pay attention to the above two points, while ordinary value attributes will be copied directly and this problem will not occur. Two other concepts are involved here: Shallow copy and Deep copy
• Shallow copy means that all variables of the copied object contain the same variables as the original object. value, and all references to other objects still point to the original object
• Deep copy points the variable of the referenced object to the copied new object, not the original referenced object
• Regarding the issues of references and values, we will explain them in other articles. Please follow WeChat or Nuggets account

##Original address: https://juejin.cn/post/ 6844903942220939272

Author: Hardcore Project Manager

Recommended learning: "

PHP Video Tutorial"

The above is the detailed content of Learn about the prototype pattern in PHP in one article. For more information, please follow other related articles on the PHP Chinese website!