There are three ways to implement deep copy of arrays in PHP: First, use unserialize and serialize to disconnect references by serializing and deserializing, which is suitable for ordinary and nested arrays; second, object arrays combine clone and recursive functions to flexibly process mixed types but ensure that the class supports correct cloning; third, json_encode and json_decode are suitable for pure scalar data, with simple writing but no resources or special objects.

When you process an array in PHP, you sometimes need to copy an array without affecting the original data. If you just simply assign values, you might get a shallow copy, especially when the array contains objects or multi-dimensional structures. At this time , deep copy is needed.

PHP does not have a special "deep copy" function, but similar effects can be achieved in several ways.

Use unserialize and serialize

This is the most commonly used and direct way:

 $original = [ ['name' => 'Alice'], ['name' => 'Bob'] ];
$copy = unserialize(serialize($original));

• This method completely disconnects the relationship between $copy and $original .
• The principle is to serialize the array into a string first, and then deserialize it back, which is equivalent to reconstructing a new array.
• Suitable for most cases of normal and nested arrays.

What should be noted is:
This method fails if the array contains resource types (such as file handles); in addition, for objects, this method creates new instances, but may have side effects if the __sleep() or __wakeup() methods are defined in the class.

Object arrays can be recursive with cloning

If you have a lot of objects in your array and you want to really copy them deeply, you can combine clone and recursive functions:

 function deepCopy($array) {
    $result = [];
    foreach ($array as $key => $value) {
        if (is_array($value)) {
            $result[$key] = deepCopy($value);
        } elseif (is_object($value)) {
            $result[$key] = clone $value;
        } else {
            $result[$key] = $value;
        }
    }
    return $result;
}

This method is more flexible and can also handle arrays of mixed types, but be aware of:

• If there are nested references or resources inside the object, clone may not be able to be completely copied;
• It is necessary to ensure that the object class supports correct cloning behavior, otherwise it may still be a shallow copy.

Simple arrays can be used directly with json_decode and json_encode

If you are sure that the contents of the array are all basic types (strings, numbers, arrays, etc.), you can also try the JSON method:

 $original = [1, 2, [3, 4]];
$copy = json_decode(json_encode($original), true);

The advantage is that it is simple in writing and can indeed disconnect quotations.

The disadvantages are:

• Resources or special objects are not supported;
• Formats such as time and date may be converted into strings;
• Integer keys will be automatically re-indexed (if it is an associative array, it is recommended to set to true as the second parameter).

To summarize the applicable scenarios:

• Ordinary array (including multi-dimensional) : the preferred unserialize(serialize())
• Arrays with objects : consider custom recursive clone
• Pure scalar data : it is easier to use json_encode/decode

Basically, these methods are all. Although PHP does not have a built-in deep copy function, these techniques can already meet most of the needs.

The above is the detailed content of how to deep copy a php array. For more information, please follow other related articles on the PHP Chinese website!