How To Copy A PHP Array?

Using Assignment Operator (=)

PHP uses a copy-on-write mechanism for scalar values in arrays. When you assign one array to another using the assignment operator (=), PHP creates a shallow copy of the original array. For arrays with only scalar values (like integers, strings, or booleans), this method creates a new, independent copy of the array.

$original = [1, 2, 3];
$copy = $original;
$copy[0] = 4;

// $original remains [1, 2, 3]
// $copy is now [4, 2, 3]

This method has limits. If the array contains objects or nested arrays, only the references to these elements are copied, not the objects or nested arrays themselves.

Using array_slice() Function

The array_slice() function can create a copy of an array by extracting a portion of it. When used without specifying start and length parameters, it creates a complete copy of the array.

$original = [1, 2, 3];
$copy = array_slice($original, 0);

This method is useful when you want to copy a specific portion of an array or when you need to reset array keys. It works well for one-dimensional arrays but doesn't create deep copies of nested structures.

Using array_merge() Function

The array_merge() function can be used to copy arrays by merging the original array with an empty array.

$original = [1, 2, 3];
$copy = array_merge([], $original);

This method is good for one-dimensional arrays. It creates a new array and copies all elements from the original array into it. Like array_slice(), it doesn't create deep copies of nested structures or objects within the array.

Each of these methods has its own uses and limits. The choice depends on your project's needs and the structure of the arrays you're working with.

$original = ['a' => 1, 'b' => 2, 'c' => 3];
$copy = array_merge([], $original);
// $copy is now ['a' => 1, 'b' => 2, 'c' => 3]

Deep Copying with serialize() and unserialize()

Deep copying creates a new array where all nested elements are copied, not just referenced. This is useful when working with complex array structures containing nested arrays or objects.

The serialize() and unserialize() functions provide a way to perform deep copying in PHP:

$original = [1, [2, 3], new stdClass()];
$copy = unserialize(serialize($original));

This method works by first converting the array and its contents into a string representation (serialize()), then reconstructing it into a new array (unserialize()). This creates an independent copy of the original array, including all nested elements.

Using the clone Keyword

The clone keyword in PHP is used for creating copies of objects. When applied to an object, it creates a shallow copy of that object.

$original = new SomeClass();
$copy = clone $original;

However, the clone keyword has limits when dealing with nested objects or arrays within the cloned object. It only creates a shallow copy, meaning that nested objects or arrays are still referenced, not copied.

To address this limit, you can implement the __clone() magic method in your classes to define custom behavior during cloning:

class MyClass {
    public $nestedArray;

    public function __clone() {
        $this->nestedArray = array_map(function($item) {
            return is_object($item) ? clone $item : $item;
        }, $this->nestedArray);
    }
}

This implementation allows for a deeper copy of nested elements when cloning objects.

$original = [1, [2, 3], [4, [5, 6]]];
$copy = array_map(function($element) {
    return is_array($element) ? array_map(function($e) {
        return is_array($e) ? array_map('strval', $e) : $e;
    }, $element) : $element;
}, $original);

Copying Multidimensional Arrays

Copying multidimensional arrays in PHP can be tricky. Simple assignment or shallow copying methods often don't work well with nested structures. These methods only copy the top-level elements, leaving nested arrays as references to the original data.

To copy multidimensional arrays, you need to do a deep copy. Here's a function that can do this:

function deepCopyArray($array) {
    $copy = [];
    foreach ($array as $key => $value) {
        if (is_array($value)) {
            $copy[$key] = deepCopyArray($value);
        } else {
            $copy[$key] = $value;
        }
    }
    return $copy;
}

This function goes through each element of the array. If it finds a nested array, it calls itself to copy that nested array. This continues until all levels of the array are copied.

$original = [
    'fruits' => ['apple', 'banana'],
    'vegetables' => [
        'green' => ['spinach', 'broccoli'],
        'red' => ['tomato', 'pepper']
    ]
];
$copy = deepCopyArray($original);
$copy['vegetables']['green'][0] = 'kale';
// $original remains unchanged

Copying Arrays with Object Elements

Copying arrays with object elements is more complex. When you copy an array with object elements using standard methods, you're only copying references to those objects, not the objects themselves.

To copy arrays containing objects, you need to create new instances of each object. Here's how you can do this:

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

This function checks if each element is an object, an array, or a scalar value. For objects, it uses the clone keyword to create a new instance. For arrays, it calls itself. For scalar values, it copies the value.

The clone keyword does a shallow copy of objects. If your objects have nested objects or arrays, you might need to create a custom __clone() method in your classes to do a deep copy of their properties.

Using json_encode() and json_decode()

The json_encode() and json_decode() functions offer a way to copy arrays in PHP, especially for arrays with simple structures. This method works by converting the array to a JSON string and then back to a PHP array.

$original = ['a' => 1, 'b' => 2, 'c' => [3, 4, 5]];
$copy = json_decode(json_encode($original), true);

This approach works for arrays containing JSON-compatible data types (numbers, strings, booleans, null, arrays, and objects with public properties).

However, this method has limits with complex data types:

1. It doesn't handle resources or closures.
2. Object properties that are not public are lost.
3. It may not keep the original object types, converting them to stdClass objects instead.

Implementing a Custom Recursive Function

For complex arrays with nested structures or objects, a custom recursive function can provide more control in the copying process.

Benefits of a custom function include:

1. Ability to handle specific object types or data structures.
2. More control over how different elements are copied.
3. Option to add error handling or logging.

Here's an example of implementing such a function:

function customDeepCopy($array) {
    $copy = [];
    foreach ($array as $key => $value) {
        if (is_array($value)) {
            $copy[$key] = customDeepCopy($value);
        } elseif (is_object($value)) {
            $copy[$key] = cloneObject($value);
        } else {
            $copy[$key] = $value;
        }
    }
    return $copy;
}

function cloneObject($object) {
    if (method_exists($object, '__clone')) {
        return clone $object;
    }
    $objectCopy = new stdClass();
    foreach ($object as $key => $value) {
        if (is_array($value)) {
            $objectCopy->$key = customDeepCopy($value);
        } elseif (is_object($value)) {
            $objectCopy->$key = cloneObject($value);
        } else {
            $objectCopy->$key = $value;
        }
    }
    return $objectCopy;
}

This custom function recursively copies arrays and objects, handling nested structures and keeping object types when possible.