对象复制

在多数情况下,我们并不需要完全复制一个对象来获得其中属性。但有一个情况下确实需要:如果你有一个 GTK 窗口对象,该对象持有窗口相关的资源。你可能会想复制一个新的窗口,保持所有属性与原来的窗口相同,但必须是一个新的对象(因为如果不是新的对象,那么一个窗口中的改变就会影响到另一个窗口)。还有一种情况:如果对象 A 中保存着对象 B 的引用,当你复制对象 A 时,你想其中使用的对象不再是对象 B 而是 B 的一个副本,那么你必须得到对象 A 的一个副本。

对象复制可以通过 clone 关键字来完成(如果可能,这将调用对象的 __clone() 方法)。对象中的 __clone() 方法不能被直接调用。

$copy_of_object = clone $object;

当对象被复制后,PHP 5 会对对象的所有属性执行一个浅复制(shallow copy)。所有的引用属性 仍然会是一个指向原来的变量的引用。

__clone ( void ) : void

当复制完成时,如果定义了 __clone() 方法,则新创建的对象(复制生成的对象)中的 __clone() 方法会被调用,可用于修改属性的值(如果有必要的话)。

Example #1 复制一个对象

<?php
class SubObject
{
    static 
$instances 0;
    public 
$instance;

    public function 
__construct() {
        
$this->instance = ++self::$instances;
    }

    public function 
__clone() {
        
$this->instance = ++self::$instances;
    }
}

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);

print(
"Cloned Object:\n");
print_r($obj2);

?>

以上例程会输出:

Original Object:
MyCloneable Object
(
    [object1] => SubObject Object
        (
            [instance] => 1
        )

    [object2] => SubObject Object
        (
            [instance] => 2
        )

)
Cloned Object:
MyCloneable Object
(
    [object1] => SubObject Object
        (
            [instance] => 3
        )

    [object2] => SubObject Object
        (
            [instance] => 2
        )

)

User Contributed Notes

flaviu dot chelaru at gmail dot com 11-Jun-2018 07:09
<?php

class Foo
{
    private
$bar = 1;

    public function
get()
    {
       
$x = clone $this;
        return
$x->bar;
    }
}
// will NOT throw exception.
// Foo::$bar property is visible internally even if called as external on the clone
print (new Foo)->get();
yinzw at chuchujie dot com 05-Jul-2016 01:10
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] =>
        )

)
fabio at naoimporta dot com 21-Feb-2016 09:53
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;
jason at jewelrysupply dot com 24-Sep-2015 09:44
@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).
stanislav dot eckert at vizson dot de 13-Dec-2014 12:53
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";
?>
jojor at gmx dot net 07-Jun-2010 01:47
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>
emile at webflow dot nl 02-Mar-2010 01:27
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."
ben at last dot fm 05-Jun-2009 10:33
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

?>
cheetah at tanabi dot org 18-Nov-2008 05:15
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.]
crrodriguez at suse dot de 12-Mar-2008 09:52
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.
Hayley Watson 17-Dec-2007 03:51
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);
MakariVerslund at gmail dot com 21-Jan-2007 04:30
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.
jorge dot villalobos at gmail dot com 30-Mar-2005 03:29
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.