PHP - clone an object that contains references to itself?

Question

What is the best way to create a clone of a complex PHP object that includes many references to itself, so that the new object's references point to its own methods and properties, not those of the original object?

I understand from the manual that $new_object = clone $old_object; creates a shallow copy that keeps references where they are. So presumably $new_object's references will point to methods on the old object?

A comment on that manual page suggests that $new_object = unserialize(serialize($old_object)); is a way to create a deep copy. Sounds promising, I'm not sure exactly what this approach would mean for my case: whether references are converted to point to the clone, or made absolute, or something else, and if does do what I want, whether it's the best way.

I'd like to know if there's an established, standard way to do this.

(Note: the object in question is a Drupal Views object, but this question is about PHP objects in general: the only important features of this object are, that it is huge, and contains many references to itself that recurse if you try to navigate the whole tree.)

score 3 · Accepted Answer · answered Apr 09 '12 at 16:29

3

A simple test will reveal what happens:

$old = new stdClass();
$old->foo = 'bar';
$old->baz = &$old;

print_r($old);

$new = unserialize(serialize($old));

$new->foo = 'new';

print_r($new);
print_r($new->baz->foo);

This code shows that the self-ref now points to the clone. http://codepad.org/dSnZ5I10

answered Apr 09 '12 at 16:29

Cal

7,067
25
28

Cool, thanks, +1. Any idea about whether this is a good generalisable and standard approach - e.g. if there are any performance drawbacks when the object is huge? Seems to perform okay in my testing but my testing is very basic. – user56reinstatemonica8 Apr 09 '12 at 16:39
1

It will get slower the bigger your object is, but so will anything. I guess it depends on how big your object is to begin with - it the serialized version takes up more than half of your memory (it's a just a sting, so `strlen()` will tell you how big it is) then this approach is bad, but otherwise the execution time should be trivial. – Cal Apr 09 '12 at 17:06
Awesome. So memory use simply == strlen(serialize($object)) - that makes sense and answers my question. Thanks! – user56reinstatemonica8 Apr 09 '12 at 17:19

score 2 · Answer 2 · answered Apr 09 '12 at 16:31

Here's some basic testing and results. Not a complete answer but hopefully useful. Also please correct me if my approach is wrong. Assume $view is an object that already contains lots of self-reference and loads of data:

      $view->somedata = "This is the default";
      $view->selfreference =& $view->somedata;

      $new = clone $view;
      $new2 = unserialize(serialize($view));

      $view->somedata = "This is view";
      $new->somedata = "This is new";
      $new2->somedata = "This is new2";

      echo("$view: ".$view->selfreference);
      echo("$new: ".$new->selfreference);
      echo("$new2: ".$new2->selfreference);

Results:

'$view: This is new'
'$new: This is new'
'$new2: This is new2'

So at first investigation, it looks like the shallow clone with clone points the self-references to the original, and the unserialize(serialize()) approach maintains the reference and points it to the new object.

So it looks like unserialize(serialize()) works and doesn't crash out with an infinite loop or excessive recursion. I'd like to hear people's thoughts on whether this is a best, standard and/or accepted approach.

PHP - clone an object that contains references to itself?

2 Answers2