I ran into the same problem of an array of objects inside of an object that I wanted to clone all pointing to the same objects. However, I agreed that serializing the data was not the answer. It was relatively simple, really:
public function __clone() {
foreach ($this->varName as &$a) {
foreach ($a as &$b) {
$b = clone $b;
}
}
}
Note, that I was working with a multi-dimensional array and I was not using the Key=>Value pair system, but basically, the point is that if you use foreach, you need to specify that the copied data is to be accessed by reference.
Objekte klonen
Eine Kopie eines Objektes mit vollständig replizierten Eigenschaften zu erzeugen, ist nicht immer das gewünschte Verhalten. Ein gutes Beispiel für die Notwendigkeit von Kopierkonstruktoren ist ein Objekt, welches ein GTK Fenster repräsentiert und dieses Objekt enthält die Ressource des GTK-Fensters. Wenn Sie ein Duplikat dieses Objektes erzeugen, könnten Sie ein neues Fenster mit gleichen Eigenschaften erzeugen wollen und das neue Objekt soll die Ressource des neuen Fensters speichern. Ein weiteres Beispiel ist ein Objekt, welches eine Referenz auf ein anderes Objekt, das es benutzt, hält und wenn das Vaterobjekt repliziert wird, will man eine neue Instanz dieses anderen Objektes erzeugen, damit das Replikat eine eigene Kopie besitzt.
Eine Objektkopie wird durch die Nutzung des clone Schlüsselwortes (welches wenn möglich die __clone()-Methode des Objektes aufruft) erzeugt. Die __clone()-Methode eines Objektes kann nicht direkt aufgerufen werden.
$kopie_des_objektes = clone $objekt;
Wenn ein Objekt geklont wird, wird PHP 5 eine seichte Kopie der Eigenschaften des Objektes durchführen. Alle Eigenschaften, die Referenzen auf andere Variablen sind, werden Referenzen bleiben.
void __clone
( void
)
Sobald der Klonvorgang abgeschlossen und eine __clone()- Methode definiert ist, so wird die __clone()-Methode des neu erzeugten Objekts aufgerufen, damit alle notwendigen Eigenschaften verändert werden können.
Beispiel #1 Ein Objekt klonen
<?php
class SubObject
{
static $instanzen = 0;
public $instanz;
public function __construct() {
$this->instanz = ++self::$instanzen;
}
public function __clone() {
$this->instanz = ++self::$instanzen;
}
}
class MyCloneable
{
public $objekt1;
public $objekt2;
function __clone()
{
// Erzwinge eine Kopie von this->object,
// andernfalls wird es auf das selbe Objekt zeigen
$this->objekt1 = clone $this->objekt1;
}
}
$obj = new MyCloneable();
$obj->objekt1 = new SubObject();
$obj->objekt2 = new SubObject();
$obj2 = clone $obj;
print("Original Objekt:\n");
print_r($obj);
print("geklontes Objekt:\n");
print_r($obj2);
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Original Objekt:
MyCloneable Object
(
[object1] => SubObject Object
(
[instanz] => 1
)
[object2] => SubObject Object
(
[instanz] => 2
)
)
geklontes Object:
MyCloneable Object
(
[objekt1] => SubObject Object
(
[instanz] => 3
)
[objekt2] => SubObject Object
(
[instanz] => 2
)
)
add a note
User Contributed Notes 14 notes
MakariVerslund at gmail dot com ¶
9 years ago
Hayley Watson ¶
8 years ago
It should go without saying that if you have circular references, where a property of object A refers to object B while a property of B refers to A (or more indirect loops than that), then you'll be glad that clone does NOT automatically make a deep copy!
<?php
class Foo
{
var $that;
function __clone()
{
$this->that = clone $this->that;
}
}
$a = new Foo;
$b = new Foo;
$a->that = $b;
$b->that = $a;
$c = clone $a;
echo 'What happened?';
var_dump($c);
jojor at gmx dot net ¶
6 years ago
Here is test script i wrote to test the behaviour of clone when i have arrays with primitive values in my class - as an additonal test of the note below by jeffrey at whinger dot nl
<pre>
<?php
class MyClass {
private $myArray = array();
function pushSomethingToArray($var) {
array_push($this->myArray, $var);
}
function getArray() {
return $this->myArray;
}
}
//push some values to the myArray of Mainclass
$myObj = new MyClass();
$myObj->pushSomethingToArray('blue');
$myObj->pushSomethingToArray('orange');
$myObjClone = clone $myObj;
$myObj->pushSomethingToArray('pink');
//testing
print_r($myObj->getArray()); //Array([0] => blue,[1] => orange,[2] => pink)
print_r($myObjClone->getArray());//Array([0] => blue,[1] => orange)
//so array cloned
?>
</pre>
yinzw at chuchujie dot com ¶
2 months ago
It's clearly depicted in the manual, about the mechanism of clone process:
- First, shallow copy: properties of references will keep references (refer to the same target/variable)
- Then, change content/property as requested (calling __clone method which is defined by user).
To illustrate this process, the following example codes seems better, comparing the the original version:
class SubObject
{
static $num_cons = 0;
static $num_clone = 0;
public $construct_value;
public $clone_value;
public function __construct() {
$this->construct_value = ++self::$num_cons;
}
public function __clone() {
$this->clone_value = ++self::$num_clone;
}
}
class MyCloneable
{
public $object1;
public $object2;
function __clone()
{
// 强制复制一份this->object， 否则仍然指向同一个对象
$this->object1 = clone $this->object1;
}
}
$obj = new MyCloneable();
$obj->object1 = new SubObject();
$obj->object2 = new SubObject();
$obj2 = clone $obj;
print("Original Object:\n");
print_r($obj);
echo '<br>';
print("Cloned Object:\n");
print_r($obj2);
==================
the output is as below
Original Object:
MyCloneable Object
(
[object1] => SubObject Object
(
[construct_value] => 1
[clone_value] =>
)
[object2] => SubObject Object
(
[construct_value] => 2
[clone_value] =>
)
)
<br>Cloned Object:
MyCloneable Object
(
[object1] => SubObject Object
(
[construct_value] => 1
[clone_value] => 1
)
[object2] => SubObject Object
(
[construct_value] => 2
[clone_value] =>
)
)
jorge dot villalobos at gmail dot com ¶
11 years ago
I think it's relevant to note that __clone is NOT an override. As the example shows, the normal cloning process always occurs, and it's the responsibility of the __clone method to "mend" any "wrong" action performed by it.
jeffrey at whinger dot nl ¶
6 years ago
For me it wasn't very clear to how this cloning of objects really worked so I made this little bit of code:
<?php
class foo
{
public $test;
public function test()
{
echo 'give us a '.$this->test."<br>\n";
}
}
class bar
{
public $foo;
public function insertFoo($foo)
{
$this->foo = $foo;
}
}
$foo = new foo();
$foo->test = 'foo';
$bar = new bar();
$bar->insertFoo($foo);
$foo->test();
$bar->foo->test();
$foo->test = 'bar';
$foo->test();
$bar->foo->test();
$bar->foo = clone $foo;
$bar->foo->test = 'woop woop';
$foo->test();
$bar->foo->test();
// result:
// give us a foo
// give us a foo
// give us a bar
// give us a bar
// give us a bar
// give us a woop woop
?>
fabio at naoimporta dot com ¶
7 months ago
It's possible to know how many clones have been created of a object. I'm think that is correct:
<?php
class Classe {
public static $howManyClones = 0;
public function __clone() {
++static::$howManyClones;
}
public static function howManyClones() {
return static::$howManyClones;
}
public function __destruct() {
--static::$howManyClones;
}
}
$a = new Classe;
$b = clone $a;
$c = clone $b;
$d = clone $c;
echo 'Clones:' . Classe::howManyClones() . PHP_EOL;
unset($d);
echo 'Clones:' . Classe::howManyClones() . PHP_EOL;
ben at last dot fm ¶
7 years ago
Here are some cloning and reference gotchas we came up against at Last.fm.
1. PHP treats variables as either 'values types' or 'reference types', where the difference is supposed to be transparent. Object cloning is one of the few times when it can make a big difference. I know of no programmatic way to tell if a variable is intrinsically a value or reference type. There IS however a non-programmatic ways to tell if an object property is value or reference type:
<?php
class A { var $p; }
$a = new A;
$a->p = 'Hello'; // $a->p is a value type
var_dump($a);
/*
object(A)#1 (1) {
["p"]=>
string(5) "Hello" // <-- no &
}
*/
$ref =& $a->p; // note that this CONVERTS $a->p into a reference type!!
var_dump($a);
/*
object(A)#1 (1) {
["p"]=>
&string(5) "Hello" // <-- note the &, this indicates it's a reference.
}
*/
?>
2. unsetting all-but-one of the references will convert the remaining reference back into a value. Continuing from the previous example:
<?php
unset($ref);
var_dump($a);
/*
object(A)#1 (1) {
["p"]=>
string(5) "Hello"
}
*/
?>
I interpret this as the reference-count jumping from 2 straight to 0. However...
2. It IS possible to create a reference with a reference count of 1 - i.e. to convert an property from value type to reference type, without any extra references. All you have to do is declare that it refers to itself. This is HIGHLY idiosyncratic, but nevertheless it works. This leads to the observation that although the manual states that 'Any properties that are references to other variables, will remain references,' this is not strictly true. Any variables that are references, even to *themselves* (not necessarily to other variables), will be copied by reference rather than by value.
Here's an example to demonstrate:
<?php
class ByVal
{
var $prop;
}
class ByRef
{
var $prop;
function __construct() { $this->prop =& $this->prop; }
}
$a = new ByVal;
$a->prop = 1;
$b = clone $a;
$b->prop = 2; // $a->prop remains at 1
$a = new ByRef;
$a->prop = 1;
$b = clone $a;
$b->prop = 2; // $a->prop is now 2
?>
crrodriguez at suse dot de ¶
8 years ago
Keep in mind that since PHP 5.2.5, trying to clone a non-object correctly results in a fatal error, this differs from previous versions where only a Warning was thrown.
emile at webflow dot nl ¶
6 years ago
Another gotcha I encountered: like __construct and __desctruct, you must call parent::__clone() yourself from inside a child's __clone() function. The manual kind of got me on the wrong foot here: "An object's __clone() method cannot be called directly."
stanislav dot eckert at vizson dot de ¶
1 year ago
This base class automatically clones attributes of type object or array values of type object recursively. Just inherit your own classes from this base class.
<?php
class clone_base
{
public function __clone()
{
$object_vars = get_object_vars($this);
foreach ($object_vars as $attr_name => $attr_value)
{
if (is_object($this->$attr_name))
{
$this->$attr_name = clone $this->$attr_name;
}
else if (is_array($this->$attr_name))
{
// Note: This copies only one dimension arrays
foreach ($this->$attr_name as &$attr_array_value)
{
if (is_object($attr_array_value))
{
$attr_array_value = clone $attr_array_value;
}
unset($attr_array_value);
}
}
}
}
}
?>
Example:
<?php
class foo extends clone_base
{
public $attr = "Hello";
public $b = null;
public $attr2 = array();
public function __construct()
{
$this->b = new bar("World");
$this->attr2[] = new bar("What's");
$this->attr2[] = new bar("up?");
}
}
class bar extends clone_base
{
public $attr;
public function __construct($attr_value)
{
$this->attr = $attr_value;
}
}
echo "<pre>";
$f1 = new foo();
$f2 = clone $f1;
$f2->attr = "James";
$f2->b->attr = "Bond";
$f2->attr2[0]->attr = "Agent";
$f2->attr2[1]->attr = "007";
echo "f1.attr = " . $f1->attr . "\n";
echo "f1.b.attr = " . $f1->b->attr . "\n";
echo "f1.attr2[0] = " . $f1->attr2[0]->attr . "\n";
echo "f1.attr2[1] = " . $f1->attr2[1]->attr . "\n";
echo "\n";
echo "f2.attr = " . $f2->attr . "\n";
echo "f2.b.attr = " . $f2->b->attr . "\n";
echo "f2.attr2[0] = " . $f2->attr2[0]->attr . "\n";
echo "f2.attr2[1] = " . $f2->attr2[1]->attr . "\n";
?>
Alexey ¶
9 years ago
To implement __clone() method in complex classes I use this simple function:
function clone_($some)
{
return (is_object($some)) ? clone $some : $some;
}
In this way I don't need to care about type of my class properties.
jason at jewelrysupply dot com ¶
1 year ago
@DPB
I believe the two functions are not quite the same. The serialize followed by deserialize method is the way I've done deep cloning in other languages (bypasses any weird clone function behavior and ensures you have a no-strings-attached copy of the object).
cheetah at tanabi dot org ¶
7 years ago
Want deep cloning without too much hassle?
<?php
function __clone() {
foreach($this as $key => $val) {
if(is_object($val)||(is_array($val))){
$this->{$key} = unserialize(serialize($val));
}
}
}
?>
That will insure any object, or array that may potentially contain objects, will get cloned without using recursion or other support methods.
[EDIT BY danbrown AT php DOT net: An almost exact function was contributed on 02-DEC-2008-10:18 by (david ashe AT metabin):
<?php
function __clone(){
foreach($this as $name => $value){
if(gettype($value)=='object'){
$this->$name= clone($this->$name);
}
}
}
?>
Giving credit where it's due. ~DPB]
[EDIT BY cmb AT php DOT net: the latter function fails to make deep copies of object arrays, and might end up with infinite recursion.]
