PHP5-Objektkopie, Klon, flache Kopie und tiefe Kopie

Der Ursprung des Objektkopierens
Warum hat ein Objekt das Konzept des „Kopierens“? Dies hängt eng mit der Wertübertragungsmethode von Objekten in PHP5 zusammen
PHP-Code

    * /** 
    * * 电视机类 
    * */ 
    * class Television   
    * {  
    *     /** 
    *      * 屏幕高度 
    *      */ 
    *     protected 
      $_screenLength = 300;  
    *       
    *     /** 
    *      * 屏幕宽度 
    *      */ 
    *     protected 
      $_screenHight  = 200;  
    *       
    *     /** 
    *      * 电视机外观颜色 
    *      */ 
    *     protected 
      $_color        = 'black';  
    *       
    *     /** 
    *      * 返回电视外观颜色 
    *      */ 
    *     public 
      function getColor()  
    *     {  
    *         return 
      $this->_color;  
    *     }  
    *       
    *     /** 
    *      * 设置电视机外观颜色 
    *      */ 
    *     public 
      function setColor($color)  
    *     {  
    *         $this->_color = (string)$color;  
    *         return 
      $this;  
    *     }  
    * }  
    *   
    * $tv1 = new Television();  
    * $tv2 = $tv1;

Dieser Code definiert eine TV-Klasse Television, $tv1 ist eine Instanz eines TV, und dann folgen wir der gewöhnlichen Variablenzuweisungsmethode Der Wert von $tv1 wird $t2 zugewiesen. Jetzt haben wir also zwei Fernseher $tv1 und $tv2. Ist das wirklich der Fall? Lass es uns testen.

PHP-Code

* echo 
      'color of tv1 is: ' . $tv1->getColor();//tv1的颜色是black 
    * echo 
      &#39;<br>&#39;;  
    * echo 
      &#39;color of tv2 is: &#39; . $tv2->getColor();//tv2的颜色是black 
    * echo 
      &#39;<br>&#39;;  
    *   
    * //把tv2涂成白色 
    * $tv2->setColor(&#39;white&#39;);  
    *   
    * echo 
      &#39;color of tv2 is: &#39; . $tv2->getColor();//tv2的颜色是white 
    * echo 
      &#39;<br>&#39;;  
    * echo 
      &#39;color of tv1 is: &#39; . $tv1->getColor();//tv1的颜色是white

Zuerst sehen wir, dass die Farben von tv1 und tv2 schwarz sind, jetzt wollen wir, dass tv2 die Farbe ändert , also stellen wir die Farbe auf Weiß ein und schauen uns dann die Farbe von tv2 an, was unseren Anforderungen zu entsprechen scheint, aber es ist nicht so glatt wie erwartet. Wenn wir uns dann die Farbe von tv1 ansehen, Wir haben festgestellt, dass tv1 auch von der schwarzen Seite zur schwarzen Seite gewechselt ist. Weiß. Wir haben die Farbe von tv1 nicht zurückgesetzt. Warum hat tv1 Schwarz in Weiß geändert? Dies liegt daran, dass die Zuweisung und Wertübertragung von Objekten in PHP5 alle durch „Referenz“ erfolgt. PHP5 verwendet Zend Engine II, Objekte werden in unabhängigen Objektstrukturen gespeichert Speichern, anstatt wie andere allgemeine Variablen in Zval gespeichert zu werden (in PHP4 werden Objekte wie allgemeine Variablen in Zval gespeichert). Speichern Sie in Zval nur den Zeiger des Objekts und nicht den Inhalt (Wert). Wenn wir ein Objekt kopieren oder ein Objekt als Parameter an eine Funktion übergeben, müssen wir die Daten nicht kopieren. Behalten Sie einfach den gleichen Objektzeiger bei und benachrichtigen Sie das Objekt, auf das dieses bestimmte Objekt jetzt zeigt, durch einen anderen zval Speichern. Da sich das Objekt selbst in Object befindet Store, alle Änderungen, die wir daran vornehmen, wirken sich auf alle zval-Strukturen aus, die Zeiger auf das Objekt enthalten – im Programm widergespiegelt, wirken sich alle Änderungen am Zielobjekt auf das Quellobjekt aus. .Das macht PHP-Objekte scheinen immer als Referenz übergeben zu werden. Das obige tv2 und tv1 verweisen also tatsächlich auf dieselbe TV-Instanz, und die Vorgänge, die wir auf tv1 oder tv2 ausführen, beziehen sich tatsächlich auf dieselbe Instanz. Unsere „Kopie“ ist also fehlgeschlagen. Es scheint, dass die direkte Variablenzuweisungsmethode das Objekt aus diesem Grund nicht kopieren kann PHP5 bietet eine Operation speziell zum Kopieren von Objekten, nämlich das Klonen. Hier kommt das Kopieren von Objekten ins Spiel.


Klonen verwenden, um Objekte zu kopieren
Wir verwenden jetzt die Klon-Sprachstruktur von PHP5, um Objekte zu kopieren. Der Code lautet wie folgt:
[Größe= ​​0]PHP-Code

    * [size=+0]$tv1 = new Television();  
    * $tv2 = clone $tv1;  
    * 
    * echo 
      'color of tv1 is: ' . $tv1->getColor();//tv1的颜色是black 
    * echo 
      &#39;<br>&#39;;  
    * echo 
      &#39;color of tv2 is: &#39; . $tv2->getColor();//tv2的颜色是black 
    * echo 
      &#39;<br>&#39;;  
    * 
    * //把tv2换成涂成白色 
    * $tv2->setColor(&#39;white&#39;);  
    * 
    * echo 
      &#39;color of tv2 is: &#39; . $tv2->getColor();//tv2的颜色是white 
    * echo 
      &#39;<br>&#39;;  
    * echo 
      &#39;color of tv1 is: &#39; . $tv1->getColor();//tv1的颜色是black

In der zweiten Zeile dieses Codes verwenden wir das Schlüsselwort clone, um tv1, tv2 zu kopieren. Wir folgen weiterhin der vorherigen Methode, um festzustellen, ob die Kopie erfolgreich ist . Wir können sehen, dass wir die Farbe von tv2 in Weiß geändert haben und die Farbe von tv1 immer noch schwarz ist, sodass unser Kopiervorgang erfolgreich ist.



__Klon-Zaubermethode

Nun betrachten wir die Situation, dass jeder Fernseher eine eigene Nummer haben sollte, genau wie unsere ID-Nummer. Wenn wir also einen Fernseher kopieren, möchten wir nicht, dass diese Nummer kopiert wird, um Ärger zu vermeiden. Eine von uns entwickelte Strategie besteht darin, die zugewiesenen TV-Nummern zu löschen und sie dann je nach Bedarf neu zuzuweisen.
Dann wird die __clone Magic-Methode speziell zur Lösung solcher Probleme verwendet. Die __clone Magic-Methode wird ausgelöst, wenn das Objekt kopiert wird (dh der Klonvorgang). Wir haben den Code der TV-Klasse Television geändert und das Zahlenattribut und die __clone-Methode hinzugefügt. Der Code lautet wie folgt.
PHP-Code

    * /** 
    * * 电视机类 
    * */ 
    * class Television   
    * {  
    *       
    *     /** 
    *      * 电视机编号 
    *      */ 
    *     protected 
      $_identity    = 0;  
    *       
    *     /** 
    *      * 屏幕高度 
    *      */ 
    *     protected 
      $_screenLength = 300;  
    *       
    *     /** 
    *      * 屏幕宽度 
    *      */ 
    *     protected 
      $_screenHight  = 200;  
    *       
    *     /** 
    *      * 电视机外观颜色 
    *      */ 
    *     protected 
      $_color        = 'black';  
    *       
    *     /** 
    *      * 返回电视外观颜色 
    *      */ 
    *     public 
      function getColor()  
    *     {  
    *         return 
      $this->_color;  
    *     }  
    *       
    *     /** 
    *      * 设置电视机外观颜色 
    *      */ 
    *     public 
      function setColor($color)  
    *     {  
    *         $this->_color = (string)$color;  
    *         return 
      $this;  
    *     }  
    *   
    *    /** 
    *      * 返回电视机编号 
    *      */ 
    *     public 
      function getIdentity()  
    *     {  
    *         return 
      $this->_identity;      
    *     }  
    *       
    *     /** 
    *      * 设置电视机编号 
    *      */ 
    *     public 
      function setIdentity($id)  
    *     {  
    *         $this->_identity = (int)$id;  
    *         return 
      $this;  
    *     }  
    *       
    *     public 
      function __clone()  
    *     {  
    *         $this->setIdentity(0);   
    *     }  
    * }

Kopieren wir so ein TV-Objekt.

PHP-Code

    * $tv1 = new Television();  
    * $tv1->setIdentity('111111');  
    * echo 
      'id of tv1 is ' . $tv1->getIdentity();//111111  
    * echo 
      &#39;<br>&#39;;  
    *   
    * $tv2 = clone $tv1;  
    * echo 
      &#39;id of tv2 is &#39; . $tv2->getIdentity();//0

Wir haben einen Fernseher tv1 produziert, Und setzen Sie seine Nummer auf 111111, dann kopieren wir tv1, um tv2 zu erhalten. Zu diesem Zeitpunkt wird die magische Methode __clone ausgelöst. Diese Methode wird direkt auf das kopierte Objekt tv2 angewendet. Die Methode löscht das _identity-Attribut von tv2, damit wir es später neu nummerieren können. Daraus können wir ersehen, dass wir mit der magischen Methode __clone einige zusätzliche Vorgänge beim Klonen eines Objekts sehr bequem ausführen können.

Fataler Fehler beim Klonvorgang
Kann das Klonen wirklich den idealen Kopiereffekt erzielen? In einigen Fällen sollten Sie feststellen, dass der Klonvorgang nicht so perfekt ist, wie wir es uns vorgestellt haben. Lassen Sie uns den oben genannten TV-Typ ändern und dann einen Test durchführen.
Jeder Fernseher wird mit einer Fernbedienung geliefert, daher haben wir eine Fernbedienungsklasse. Die Fernbedienung und der Fernseher stehen in einer „Aggregations“-Beziehung (im Vergleich zur „Kombinations“-Beziehung, die eine schwächere Abhängigkeitsbeziehung darstellt Im Allgemeinen kann der Fernseher auch ohne Fernbedienung normal verwendet werden. Jetzt sollten unsere TV-Objekte alle eine Referenz auf das Fernbedienungsobjekt enthalten. Schauen wir uns den Code unten an
PHP-Code

    * /** 
    * * 电视机类 
    * */ 
    * class Television   
    * {  
    *       
    *     /** 
    *      * 电视机编号 
    *      */ 
    *     protected 
      $_identity    = 0;  
    *       
    *     /** 
    *      * 屏幕高度 
    *      */ 
    *     protected 
      $_screenLength = 300;  
    *       
    *     /** 
    *      * 屏幕宽度 
    *      */ 
    *     protected 
      $_screenHight  = 200;  
    *       
    *     /** 
    *      * 电视机外观颜色 
    *      */ 
    *     protected 
      $_color        = 'black';  
    *       
    *     /** 
    *      * 遥控器对象 
    *      */ 
    *     protected 
      $_control      = null;  
    *       
    *     /** 
    *      * 构造函数中加载遥控器对象 
    *      */ 
    *     public 
      function __construct()  
    *     {  
    *         $this->setControl(new Telecontrol());  
    *     }  
    *   
    *     /** 
    *      * 设置遥控器对象 
    *      */ 
    *     public 
      function setControl(Telecontrol $control)  
    *     {  
    *         $this->_control = $control;  
    *         return 
      $this;  
    *     }  
    *       
    *     /** 
    *      * 返回遥控器对象 
    *      */ 
    *     public 
      function getControl()  
    *     {  
    *         return 
      $this->_control;  
    *     }      
    *       
    *     /** 
    *      * 返回电视外观颜色 
    *      */ 
    *     public 
      function getColor()  
    *     {  
    *         return 
      $this->_color;  
    *     }  
    *       
    *     /** 
    *      * 设置电视机外观颜色 
    *      */ 
    *     public 
      function setColor($color)  
    *     {  
    *         $this->_color = (string)$color;  
    *         return 
      $this;  
    *     }  
    *   
    *    /** 
    *      * 返回电视机编号 
    *      */ 
    *     public 
      function getIdentity()  
    *     {  
    *         return 
      $this->_identity;      
    *     }  
    *       
    *     /** 
    *      * 设置电视机编号 
    *      */ 
    *     public 
      function setIdentity($id)  
    *     {  
    *         $this->_identity = (int)$id;  
    *         return 
      $this;  
    *     }  
    *       
    *     public 
      function __clone()  
    *     {  
    *         $this->setIdentity(0);   
    *     }  
    * }  
    *   
    *   
    * /** 
    * * 遥控器类 
    * */ 
    * class Telecontrol   
    * {  
    *   
    * }

Kopieren Sie ein solches TV-Objekt unten und beobachten Sie das Fernbedienungsobjekt des Fernsehers.

PHP-Code

    * $tv1 = new Television();  
    * $tv2 = clone $tv1;  
    *   
    * $contr1 = $tv1->getControl(); //获取tv1的遥控器contr1 
    * $contr2 = $tv2->getControl(); //获取tv2的遥控器contr2 
    * echo 
      $tv1;    //tv1的object id 为 #1 
    * echo 
      &#39;<br>&#39;;  
    * echo 
      $contr1; //contr1的object id 为#2 
    * echo 
      &#39;<br>&#39;;   
    * echo 
      $tv2;    //tv2的object id 为 #3 
    * echo 
      &#39;<br>&#39;;  
    * echo 
      $contr2; //contr2的object id 为#2

经过复制之后，我们查看对象id，通过clone操作从tv1复制出了tv2,tv1和tv2的对象id分别是 1和3，这表示tv1和tv2是引用两个不同的电视机对象，这符合clone操作的结果。然后我们分别获取了tv1的遥控器对象contr1和tv2的遥控器对象contr2，通过查看它们的对象 id我们发现contr1和contr2的对象id都是2，这表明它们是到同一个对象的引用，也就是说我们虽然从tv1复制出tv2,但是遥控器并没有被复制，每台电视机都应该配有一个遥控器，而这里tv2和tv1共用一个遥控器，这显然是不合常理的。 

    由此可见，clone操作有这么一个非常大的缺陷：使用clone操作复制对象时，当被复制的对象有对其它对象的引用的时候，引用的对象将不会被复制。然而这种情况又非常的普遍，现今 “合成/聚合复用”多被提倡用来代替“继承复用”，“合成”和“聚合”就是让一个对象拥有对另一个对象的引用，从而复用被引用对象的方法。我们在使用 clone的时候应该考虑到这样的情况。那么在clone对象的时候我们应该如何去解决这样的一个缺陷呢？可能你很快就想到了之前提到的__clone魔术方法，这确实是一种解决方案。 

方案1:用__clone魔术方法弥补 
    前面我们已经介绍了__clone魔术方法的用法，我们可以在__clone方法中将被复制对象中其它对象的引用重新引用到一个新的对象。下面我们看看修改后的__clone()魔术方法： 

[size=+0][size=+0]PHP代码 

    * [size=+0][size=+0]public 
      function __clone()  
    * {  
    *     $this->setIdentity(0);  
    *     //重新设置一个遥控器对象 
    *     $this->setControl(new Telecontrol());  
    * }

第04行中我们为复制出来的电视机对象重新设置了一个遥控器，我们按照之前的方法查看对象的id可以发现，两台电视机的遥控器拥有不同的对象id，这样我们的问题就解决了。 

但是这样的方式大概并不算太好，如果被复制对象中有多个到其它对象的引用，我们必须在__clone方法中逐个的重新设置，更糟糕的是如果被复制对象的类由第三方提供，我们无法修改代码，那复制操作基本就无法顺利完成了。 
我们使用clone来复制对象，这种复制叫做“浅复制”：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。也就是说，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。相对于“浅复制”，当然也有一个“深复制”：被复制的对象的所有的变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。也就是说，深复制把要复制的对象所引用的对象都复制了一遍。深复制需要决定深入到多少层，这是一个不容易确定的问题，此外可能会出现循环引用的问题，这些都必须小心处理。我们的方案2将是一个深复制的解决方案。 

方案2:利用串行化做深复制 
PHP有串行化(serialize)和反串行化(unserialize)函数，我们只需要用serialize()将一个对象写入一个流，然后从流中读回对象，那么对象就被复制了。在JAVA语言里面，这个过程叫做“冷藏”和“解冻”。下面我们将测试一下这个方法： 
[size=+0][size=+0]PHP代码 

    * [size=+0][size=+0]$tv1 = new Television();  
    * $tv2 = unserialize(serialize($tv1));//序列化然后反序列化 
    * 
    * $contr1 = $tv1->getControl(); //获取tv1的遥控器contr1 
    * $contr2 = $tv2->getControl(); //获取tv2的遥控器contr2 
    * 
    * echo 
      $tv1;    //tv1的object id 为 #1 
    * echo 
      &#39;<br>&#39;;  
    * echo 
      $contr1; //contr1的object id 为#2 
    * echo 
      &#39;<br>&#39;;   
    * echo 
      $tv2;    //tv2的object id 为 #4 
    * echo 
      &#39;<br>&#39;;  
    * echo 
      $contr2; //contr2的object id 为#5

我们可以看到输出结果，tv1和tv2拥有了不同的遥控器。这比方案1要方便很多，序列化是一个递归的过程，我们不需要理会被对象内部引用了多少个对象以及引用了多少层对象，我们都可以彻底的复制。注意使用此方案时我们无法触发__clone魔术方法来完成一些附加操作，当然我们可以在深复制之后再进行一次clone操作来触发__clone魔术方法，只是会对效率些小的影响。另外此方案会触发被复制对象和所有被引用对象的__sleep和__wakeup魔术方法，所以这些情况都需要被考虑。 



总结 
   不同的对象复制方式有着不同的效果，我们应该根据具体应用需求来考虑使用哪种方式以及如何改进复制方式。PHP5的面向对象特性和JAVA比较接近，相信我们可以从JAVA中借鉴很多宝贵的经验。