PHP 数组复制深度解析：从浅拷贝到深拷贝的最佳实践31

在 PHP 编程中，数组是一种极其灵活且常用的数据结构。然而，在处理数组时，特别是在需要创建数组的副本时，如果不理解 PHP 的底层机制，可能会遇到意想不到的行为，甚至导致难以调试的 bug。本文将深入探讨 PHP 数组的复制机制，从最基本的赋值操作到实现真正的深拷贝，帮助开发者理解其工作原理，并掌握在不同场景下选择最佳复制策略的实践。

为何数组复制如此重要？

数组复制看似简单，但在实际开发中却至关重要。想象一个场景：你从数据库中获取了一个数组作为配置，需要对其进行修改，但同时又要保留原始配置以备后续操作。如果你直接修改，而没有创建副本，那么原始配置就会被意外更改。又或者，当你将一个数组传递给函数时，如果不希望函数内部的修改影响到原始数组，就需要进行复制。理解浅拷贝（Shallow Copy）和深拷贝（Deep Copy）是解决这些问题的关键。

PHP 对数组和对象的处理方式有所不同。对于标量类型（整数、浮点数、字符串、布尔值）和数组，PHP 通常采用“写时复制”（Copy-on-Write, CoW）的优化策略。而对于对象，则是通过引用传递。这种差异是理解数组复制行为的基础。

第一章：基础复制与写时复制 (Copy-on-Write)

1.1 赋值操作符 `=`

在 PHP 中，最常见的数组复制方式是使用赋值操作符 `=`：$originalArray = ['a' => 1, 'b' => 2, 'c' => [3, 4]];
$copiedArray = $originalArray;
$copiedArray['a'] = 100;
echo "Original Array 'a': " . $originalArray['a'] . ""; // 输出: Original Array 'a': 1
echo "Copied Array 'a': " . $copiedArray['a'] . ""; // 输出: Copied Array 'a': 100

从上面的例子可以看出，修改 `$copiedArray` 中的顶级元素 'a' 并不会影响到 `$originalArray`。这看起来像是进行了深拷贝，但实际上，这得益于 PHP 的“写时复制”优化。

1.2 写时复制 (Copy-on-Write, CoW) 机制

为了优化内存使用和性能，PHP 在内部处理数组时采用了写时复制机制。当一个数组被赋值给另一个变量时，PHP 并不会立即创建原始数组的完整副本。相反，两个变量会指向内存中的同一个底层数组结构。只有当其中一个变量试图修改这个共享的数组时，PHP 才会真正地创建该数组的一个独立副本，并对副本进行修改。原始数组则保持不变。

这意味着，对于只包含标量值的简单数组，`=` 运算符在语义上表现为深拷贝，但在实际操作中却非常高效。$array1 = [1, 2, 3];
$array2 = $array1; // 此时 $array1 和 $array2 共享底层数据
$array2[0] = 100; // 发生写时复制，PHP 此时创建 $array2 的独立副本
var_dump($array1); // array(3) { [0]=> int(1) [1]=> int(2) [2]=> int(3) }
var_dump($array2); // array(3) { [0]=> int(100) [1]=> int(2) [2]=> int(3) }

然而，写时复制有一个重要的限制：它只作用于数组本身，而不是数组内部可能包含的嵌套对象。这引出了浅拷贝的概念。

第二章：浅拷贝 (Shallow Copy)

浅拷贝是指创建一个新数组，其元素是原始数组中元素的副本。但是，如果原始数组中的元素是对象，那么新数组中对应的元素将是对同一个对象的引用，而不是一个新的对象副本。这意味着，修改新数组中某个引用对象的属性会同时影响到原始数组中的对象。

2.1 `=` 运算符的浅拷贝行为（涉及对象时）

当数组中包含对象时，`=` 运算符就表现出了浅拷贝的特性：class MyObject {
public $value;
public function __construct($value) {
$this->value = $value;
}
}
$obj1 = new MyObject('original');
$originalArray = ['id' => 1, 'data' => $obj1];
$copiedArray = $originalArray; // 浅拷贝
// 修改 $copiedArray 中的对象属性
$copiedArray['data']->value = 'modified';
echo "Original Array Object Value: " . $originalArray['data']->value . ""; // 输出: Original Array Object Value: modified
echo "Copied Array Object Value: " . $copiedArray['data']->value . ""; // 输出: Copied Array Object Value: modified
// 验证 CoW 仍然作用于非对象元素
$copiedArray['id'] = 2;
echo "Original Array ID: " . $originalArray['id'] . ""; // 输出: Original Array ID: 1
echo "Copied Array ID: " . $copiedArray['id'] . ""; // 输出: Copied Array ID: 2

在这个例子中，虽然 `$copiedArray['id']` 的修改没有影响 `$originalArray['id']`（因为 CoW 对标量值有效），但 `$copiedArray['data']->value` 的修改却影响了 `$originalArray['data']->value`，因为 `$originalArray['data']` 和 `$copiedArray['data']` 仍然指向内存中的同一个 `MyObject` 实例。这就是典型的浅拷贝行为。

2.2 使用 `array_merge()` 进行浅拷贝

`array_merge()` 函数用于将一个或多个数组合并。当只有一个数组作为参数时，它会创建一个该数组的浅拷贝。如果存在相同字符串键名，则后面的值会覆盖前面的值；如果键名为数字，则会重新索引。$array1 = ['a' => 1, 'b' => 2, 'obj' => $obj1];
$array2 = array_merge($array1); // 浅拷贝
$array2['a'] = 100;
$array2['obj']->value = 'modified_by_merge';
echo "Array1 'a': " . $array1['a'] . ""; // 输出: Array1 'a': 1
echo "Array2 'a': " . $array2['a'] . ""; // 输出: Array2 'a': 100
echo "Array1 'obj' value: " . $array1['obj']->value . ""; // 输出: Array1 'obj' value: modified_by_merge

同样，对于嵌套对象，`array_merge()` 仍然是浅拷贝。

2.3 使用 `array_replace()` 进行浅拷贝

`array_replace()` 函数用于用后面数组的值替换前面数组的值。与 `array_merge()` 类似，当用于单个数组时，也可以实现浅拷贝。$array1 = ['a' => 1, 'b' => 2, 'obj' => $obj1];
$array2 = array_replace($array1); // 浅拷贝
$array2['a'] = 200;
$array2['obj']->value = 'modified_by_replace';
echo "Array1 'a': " . $array1['a'] . ""; // 输出: Array1 'a': 1
echo "Array2 'a': " . $array2['a'] . ""; // 输出: Array2 'a': 200
echo "Array1 'obj' value: " . $array1['obj']->value . ""; // 输出: Array1 'obj' value: modified_by_replace

其行为与 `array_merge()` 在浅拷贝方面的表现一致。

2.4 使用 `+` 运算符（数组联合）进行浅拷贝

PHP 的 `+` 运算符用于数组联合。它会将右侧数组中所有键名在左侧数组中不存在的元素添加到左侧数组中。如果键名在左侧数组中已存在，则左侧数组的值会被保留。$array1 = ['a' => 1, 'b' => 2, 'obj' => $obj1];
$array2 = $array1 + []; // 效果上是浅拷贝 $array1 + 一个空数组，可以创建一个副本
$array2['a'] = 300;
$array2['obj']->value = 'modified_by_plus';
echo "Array1 'a': " . $array1['a'] . ""; // 输出: Array1 'a': 1
echo "Array2 'a': " . $array2['a'] . ""; // 输出: Array2 'a': 300
echo "Array1 'obj' value: " . $array1['obj']->value . ""; // 输出: Array1 'obj' value: modified_by_plus

同样，`+` 运算符在处理对象时也表现为浅拷贝。

第三章：深拷贝 (Deep Copy)

深拷贝是指创建一个全新的数组，不仅复制了原始数组中的所有标量值，还递归地复制了所有嵌套的对象和数组，使得新数组完全独立于原始数组。任何对新数组的修改都不会影响到原始数组。

3.1 使用 `serialize()` 和 `unserialize()`

这是在 PHP 中实现深拷贝最常用且相对通用的方法。`serialize()` 函数将一个 PHP 值转换为可存储的字符串，`unserialize()` 函数则将字符串还原为原始的 PHP 值。class MyObject {
public $value;
public function __construct($value) {
$this->value = $value;
}
}
$obj1 = new MyObject('original');
$originalArray = ['id' => 1, 'data' => $obj1, 'nested' => ['foo' => 'bar']];
// 深拷贝
$serializedArray = serialize($originalArray);
$deepCopiedArray = unserialize($serializedArray);
$deepCopiedArray['id'] = 100;
$deepCopiedArray['data']->value = 'modified_deep';
$deepCopiedArray['nested']['foo'] = 'baz';
echo "Original Array ID: " . $originalArray['id'] . ""; // 输出: Original Array ID: 1
echo "Deep Copied Array ID: " . $deepCopiedArray['id'] . ""; // 输出: Deep Copied Array ID: 100
echo "Original Array Object Value: " . $originalArray['data']->value . ""; // 输出: Original Array Object Value: original
echo "Deep Copied Array Object Value: " . $deepCopiedArray['data']->value . ""; // 输出: Deep Copied Array Object Value: modified_deep
echo "Original Array Nested Foo: " . $originalArray['nested']['foo'] . ""; // 输出: Original Array Nested Foo: bar
echo "Deep Copied Array Nested Foo: " . $deepCopiedArray['nested']['foo'] . ""; // 输出: Deep Copied Array Nested Foo: baz

优点：

通用性强：能够处理标量、数组和大多数对象（包括嵌套的对象）。
实现简单：只需要两行代码即可完成。
处理循环引用： `serialize()` 可以很好地处理对象之间的循环引用，避免无限递归。

缺点：

性能开销：序列化和反序列化过程通常比简单赋值或浅拷贝消耗更多的时间和内存，特别是对于大型或复杂的数组结构。
无法序列化资源类型：像文件句柄（`resource` 类型）、数据库连接等资源类型无法被 `serialize()`。
无法序列化匿名函数（closures）： PHP 7.4+ 开始支持序列化匿名函数，但仍有限制，并非所有情况都适用。
魔术方法 `__sleep()` 和 `__wakeup()`：对象的 `__sleep()` 和 `__wakeup()` 魔术方法会在序列化/反序列化时被调用，这可能引入额外的逻辑，有时需要小心处理。

3.2 使用 `json_encode()` 和 `json_decode()`

另一种常用的深拷贝方法是利用 JSON 编码和解码。这对于那些需要与 JavaScript 等其他系统交互，或者数据结构相对扁平的数组特别有用。class MyObject {
public $value;
public function __construct($value) {
$this->value = $value;
}
}
$obj1 = new MyObject('original');
$originalArray = ['id' => 1, 'data' => $obj1, 'nested' => ['foo' => 'bar']];
// 深拷贝
$jsonArray = json_encode($originalArray);
$deepCopiedArray = json_decode($jsonArray, true); // true 表示解码为关联数组
$deepCopiedArray['id'] = 200;
// 注意：对象会被转换为关联数组，需要额外处理
$deepCopiedArray['data']['value'] = 'modified_json';
$deepCopiedArray['nested']['foo'] = 'qux';
echo "Original Array ID: " . $originalArray['id'] . ""; // 输出: Original Array ID: 1
echo "Deep Copied Array ID: " . $deepCopiedArray['id'] . ""; // 输出: Deep Copied Array ID: 200
echo "Original Array Object Value: " . $originalArray['data']->value . ""; // 输出: Original Array Object Value: original
// 原始对象未受影响
echo "Deep Copied Array Object (converted to array) Value: " . $deepCopiedArray['data']['value'] . ""; // 输出: Deep Copied Array Object (converted to array) Value: modified_json
echo "Original Array Nested Foo: " . $originalArray['nested']['foo'] . ""; // 输出: Original Array Nested Foo: bar
echo "Deep Copied Array Nested Foo: " . $deepCopiedArray['nested']['foo'] . ""; // 输出: Deep Copied Array Nested Foo: qux

优点：

跨语言兼容： JSON 是一种标准的数据交换格式，易于与前端 JavaScript 或其他后端服务交互。
可读性好： JSON 字符串是人类可读的。
实现简单：同样只需要两行代码。

缺点：

对象处理： `json_encode()` 默认会将对象转换为关联数组（如果对象实现了 `JsonSerializable` 接口或具有可访问的公共属性）。反序列化后，你将得到一个关联数组而不是原始类的对象实例。这意味着它不是“真正的”深拷贝，因为它改变了嵌套对象的类型。如果需要保持对象类型，则不适用。
数据类型转换： JSON 对数据类型有自己的规范，例如，纯数字字符串可能会被转换为数字类型，`null` 会被转换为 `null`，空数组 `[]` 和空对象 `{}` 在 PHP 中都可能被 `json_decode([], true)` 解码为空数组 `[]`。
无法处理资源类型和闭包：与 `serialize()` 类似，无法处理资源类型和闭包。
无法处理私有/保护属性： `json_encode()` 只能编码对象的公共属性。私有和保护属性会被忽略。
性能开销：与 `serialize()` 类似，也存在性能开销。

3.3 自定义递归深拷贝函数

在某些特定场景下，例如：
需要对特定类型的对象进行特殊处理（例如，只复制某些属性）。
避免 `serialize()` 的限制（如资源类型）。
需要保持对象类型，且不希望使用 `json_encode()` 转换对象为数组。
对象具有复杂的构造函数或初始化逻辑，直接 `unserialize()` 或 `json_decode()` 可能无法正确还原。

这时，可以考虑编写一个自定义的递归深拷贝函数。这通常需要结合 `is_array()`、`is_object()`、`clone` 关键字等。function deepCopyArray(array $array): array {
$result = [];
foreach ($array as $key => $value) {
if (is_array($value)) {
$result[$key] = deepCopyArray($value); // 递归处理嵌套数组
} elseif (is_object($value)) {
$result[$key] = clone $value; // 克隆对象
} else {
$result[$key] = $value; // 直接赋值标量值
}
}
return $result;
}
class MyObject {
public $value;
public function __construct($value) {
$this->value = $value;
}
}
$obj1 = new MyObject('original');
$originalArray = ['id' => 1, 'data' => $obj1, 'nested' => ['foo' => 'bar']];
$deepCopiedArray = deepCopyArray($originalArray);
$deepCopiedArray['id'] = 300;
$deepCopiedArray['data']->value = 'modified_custom';
$deepCopiedArray['nested']['foo'] = 'xyz';
echo "Original Array ID: " . $originalArray['id'] . ""; // 输出: Original Array ID: 1
echo "Deep Copied Array ID: " . $deepCopiedArray['id'] . ""; // 输出: Deep Copied Array ID: 300
echo "Original Array Object Value: " . $originalArray['data']->value . ""; // 输出: Original Array Object Value: original
echo "Deep Copied Array Object Value: " . $deepCopiedArray['data']->value . ""; // 输出: Deep Copied Array Object Value: modified_custom
echo "Original Array Nested Foo: " . $originalArray['nested']['foo'] . ""; // 输出: Original Array Nested Foo: bar
echo "Deep Copied Array Nested Foo: " . $deepCopiedArray['nested']['foo'] . ""; // 输出: Deep Copied Array Nested Foo: xyz

优点：

高度可控：可以精确控制每个元素的复制方式，包括对特定对象属性的自定义处理。
保持类型：可以确保嵌套对象在复制后仍然是原始的类实例。
避免序列化限制：可以处理 `serialize()` 无法处理的资源类型（虽然需要特殊逻辑）。

缺点：

复杂性：实现相对复杂，尤其是在处理循环引用、私有/保护属性、父类构造函数调用等情况时。
性能：手动迭代通常不如 C 扩展实现的 `serialize`/`unserialize` 快速。
`__clone()` 魔术方法：如果对象定义了 `__clone()` 魔术方法，它会在对象被克隆时自动调用，允许在克隆过程中执行自定义的复制逻辑（例如，克隆对象内部的引用）。

第四章：数组复制的性能考量

选择数组复制方法时，除了功能正确性，性能也是一个重要因素。
写时复制 (CoW)：对于只包含标量值的数组，CoW 是最快的，因为它避免了不必要的内存分配和数据复制，直到真正需要修改时才发生。
浅拷贝：使用 `array_merge()`、`array_replace()` 或直接赋值（当包含对象时）的浅拷贝通常比深拷贝快，因为它们只复制顶层值，不对嵌套对象进行递归复制。
深拷贝（`serialize`/`unserialize` 和 `json_encode`/`json_decode`）：这两种方法涉及字符串的序列化/反序列化和解析，会产生显著的 CPU 和内存开销。对于非常大的数组或在性能敏感的循环中，应谨慎使用。`serialize` 通常比 `json_encode` 稍慢，但前者更强大，因为它能完整地保存 PHP 类型信息和所有对象属性（包括私有/保护属性）。
自定义递归深拷贝：性能取决于实现细节，如果处理逻辑复杂，可能会比内置函数慢。但如果优化得当，且针对特定场景，其性能可能介于浅拷贝和通用序列化之间。

在大多数情况下，如果只需要复制一个只包含标量值的简单数组，直接赋值 (`=`) 是最佳选择。如果数组中包含对象，并且你不希望修改副本影响原始对象，那么深拷贝是必需的。此时，权衡 `serialize` 的通用性和 `json_encode` 的类型转换/兼容性以及性能，选择最适合当前场景的方法。

第五章：最佳实践与注意事项
理解数据结构：在复制数组前，首先要明确数组中是否包含嵌套的数组或对象。这是决定采用浅拷贝还是深拷贝的关键。
避免不必要的深拷贝：如果你确定修改副本不会影响原始数据，或者只修改标量值，那么简单的赋值 (`=`) 或浅拷贝就已经足够，并且性能更优。深拷贝的开销不容忽视。
对象克隆的 `__clone()` 魔术方法：如果你的对象需要特殊的复制逻辑（例如，对象内部还包含对其他对象的引用，需要在克隆时也复制这些引用），请在对象类中实现 `__clone()` 魔术方法。
资源类型处理： `serialize()` 和 `json_encode()` 都无法正确处理资源类型（如数据库连接、文件句柄）。如果数组中包含这类数据，你可能需要编写自定义的复制逻辑。
JSON 的类型转换：使用 `json_encode()` 和 `json_decode()` 进行深拷贝时，请注意 JSON 的类型系统可能导致数据类型转换（例如，纯数字字符串转为数字），并且对象会被转换为关联数组。如果需要保持对象类型，这可能不是最佳选择。
测试：无论选择哪种复制方法，都应该编写测试用例来验证副本是否按照预期独立于原始数组。
文档化：在代码中明确说明你正在进行浅拷贝还是深拷贝，以及选择该方法的原因，这对于团队协作和未来的代码维护至关重要。

PHP 数组的复制并非简单的 `=` 赋值。写时复制机制优化了简单数组的性能，但当数组中包含对象时，便会涉及到浅拷贝和深拷贝的语义差异。理解这些差异，并根据数据结构的复杂性、对独立性的要求以及性能考量，选择合适的复制策略，是编写健壮、高效 PHP 代码的关键。

在多数情况下：
对于只包含标量值的数组，直接赋值 (`=`) 足矣。
对于包含对象，且不需要独立对象副本的情况，浅拷贝方法（如 `array_merge()` 或直接赋值）可以接受。
对于需要完全独立副本，包括所有嵌套对象的情况，`serialize()` 和 `unserialize()` 是最通用和可靠的选择，但需注意性能和资源类型限制。
如果数据结构允许，`json_encode()` 和 `json_decode()` 也是一个简便方法，但需警惕其对对象和数据类型的处理。
面对高度定制化或极端复杂的数据结构，自定义递归深拷贝函数提供了最大的灵活性。

作为专业的程序员，我们不仅要知其然，更要知其所以然。掌握 PHP 数组复制的深层机制，将使你在日常开发中更加游刃有余。

2025-11-07

上一篇：PHP数字ID变身短链接与邀请码：深入解析短字符串生成技术

下一篇：PHP 文件更新时间：深入理解与实战应用