Wayne Haffenden

I spent many hours yesterday trying to create an exact deep clone of a complex object structure, so that i could make changes to the clone without any affect to the original. I started by using the PHP 5 Object Clone functionality, which creates a shallow copy of all the object's properties, however any properties that are references to other variables, will remain references. This is great, but i needed a deep copy of the object including all references to child objects, however deeply nested. The PHP manual states that when cloning an object, the magic __clone() method is called if possible, which can be used to manually create a deep clone of the object.

Using the magic clone method was a step forwards, i could traverse through the object's properties and any that were references i could create clones of, however this meant that any of the object's properties that were object's that had references were still not cloned. I started implementing an interface and abstract base class, that when derived could clone an object's properties and any that also derived from the same abstract base class could also be cloned, creating a recursive cloning process. This worked perfectly until i hit object properties that were arrays of objects, at which point i decided it was time to take a step back and look for an alternative approach.

It then hit me that if i use the PHP Serialisation functionality to create a byte-stream string representation of the entire object structure and then de-serialise the byte-stream back into the object structure again, that the entire new object would be re-created and therefore be a clone of the original. It worked like a dream, so i've encapsulated it into a static class for re-usablility and have made it open-source. Hopefully the following code will save someone the time that it took me to finally achieve simple deep cloning of an object however complex its structure.

ObjectCloner.php

<?php
final class ObjectCloner
{
private function __construct() {}
public static function cloneObject($source)
{
if ($source === null)
{
return null;
}
return unserialize(serialize($source));
}
}
?>

You can use the above class as in the example class below.

Example.php

<?php
class Example
{
public function someMethod()
{
// We create an instance of some complex object.
$original = new ComplexObject();
// We create an exact clone of the complex object, using the ObjectCloner class.
$clone = ObjectCloner::cloneObject($original);
// Changing some deeply nested property on the clone will have no affect on the original.
$clone->someObjectProperty->someOtherObject->someString = 'NewValue';
echo $original->someObjectProperty->someOtherObject->someString;
// Would produce 'OriginalValue'
echo $clone->someObjectProperty->someOtherObject->someString;
// Would produce 'NewValue'
}
}
?>

I'd appreciate any feedback or comments.