php如何克隆一个对象？PHP对象克隆(clone)操作详解

穿越時空

发布时间：2025-09-12 12:49:01

390人浏览过

来源于php中文网

原创

使用clone关键字可创建对象的独立副本，避免引用共享导致的意外修改；默认为浅拷贝，需通过__clone()实现深拷贝。

php如何克隆一个对象？php对象克隆(clone)操作详解

PHP中要克隆一个对象，最直接也是最标准的方式就是使用

clone

关键字。这背后有一个核心原因：PHP的对象默认是通过引用来传递和赋值的。这意味着当你简单地将一个对象变量赋值给另一个变量时，它们实际上指向的是内存中的同一个对象实例。如果修改其中一个变量所指向的对象，另一个变量也会“看到”这些变化。而

clone

操作的目的，就是为了创建一个全新的、独立的副本，让你可以在不影响原始对象的前提下，对副本进行任何操作。

解决方案

PHP提供了一个

clone

关键字来创建对象的副本。当你对一个对象执行

clone

操作时，PHP会创建一个新的对象，并把原对象的所有属性值复制到新对象中。这听起来很简单，但实际上这里面有个关键点：默认情况下，这是一种“浅拷贝”（shallow copy）。

name = $name;
        $this->email = $email;
    }
}

$originalUser = new User('张三', 'zhangsan@example.com');
$clonedUser = clone $originalUser;

// 此时，$clonedUser 是一个独立的对象，但其属性值与 $originalUser 相同
echo "Original User Name: " . $originalUser->name . "\n"; // 输出: 张三
echo "Cloned User Name: " . $clonedUser->name . "\n";   // 输出: 张三

// 修改克隆对象的属性，不会影响原始对象
$clonedUser->name = '李四';
echo "Original User Name after clone modification: " . $originalUser->name . "\n"; // 输出: 张三
echo "Cloned User Name after clone modification: " . $clonedUser->name . "\n";   // 输出: 李四

?>

然而，如果你的对象内部包含其他对象（也就是嵌套对象），默认的

clone

行为就会显得有点“不够用”了。因为

clone

在处理这些嵌套对象时，仍然只是复制了它们的引用，而不是创建了新的嵌套对象副本。这就是所谓的浅拷贝。

为了解决这个问题，PHP提供了一个魔术方法

__clone()

。当一个对象被克隆后，如果它定义了

__clone()

方法，那么这个方法就会在新创建的克隆对象上被调用。这为我们提供了一个完美的时机，去手动处理那些需要深拷贝的嵌套对象。

立即学习“PHP免费学习笔记（深入）”；

street = $street;
        $this->city = $city;
    }
}

class Customer {
    public $name;
    public $address;

    public function __construct($name, Address $address) {
        $this->name = $name;
        $this->address = $address;
    }

    // 实现深拷贝的关键
    public function __clone() {
        // 克隆时，我们还需要手动克隆嵌套的Address对象
        // 否则，$clonedCustomer->address 仍然会指向 $originalCustomer->address
        $this->address = clone $this->address;
    }
}

$originalAddress = new Address('解放路1号', '北京');
$originalCustomer = new Customer('王五', $originalAddress);

$clonedCustomer = clone $originalCustomer;

echo "Original Customer Address Street: " . $originalCustomer->address->street . "\n"; // 输出: 解放路1号
echo "Cloned Customer Address Street: " . $clonedCustomer->address->street . "\n";   // 输出: 解放路1号

// 修改克隆客户的地址，看看会发生什么
$clonedCustomer->address->street = '人民路2号';

echo "Original Customer Address Street after clone modification: " . $originalCustomer->address->street . "\n"; // 输出: 解放路1号
echo "Cloned Customer Address Street after clone modification: " . $clonedCustomer->address->street . "\n";   // 输出: 人民路2号

// 如果没有在__clone()中手动克隆Address，那么原始客户的地址也会变成“人民路2号”
// 因为它们会指向同一个Address对象。
?>

通过在

__clone()

方法中对嵌套对象进行递归克隆，我们就能实现真正的深拷贝。这在处理复杂对象结构时，是保证数据独立性的重要手段。

为什么我们不能直接用

来复制对象，非要用

clone

呢？

这其实是PHP（以及许多其他面向对象语言）处理对象的一个基础机制。当你写下

$a = new MyObject(); $b = $a;

这样的代码时，

$b

并没有得到

$a

的一个全新副本，它只是得到了一个指向

$a

所指向的那个内存地址的“指针”或者说“引用”。你可以把对象想象成一个放在某个盒子里的东西，

$a

和

$b

只是贴在盒子上的两张标签。你通过

$a

标签打开盒子修改了里面的东西，那么通过

$b

标签打开时，你看到的也是修改后的东西，因为它们指向的是同一个盒子。

name = $name; }
}

$productA = new Product('笔记本电脑');
$productB = $productA; // 此时 $productB 和 $productA 指向同一个对象

$productB->name = '平板电脑'; // 通过 $productB 修改了对象

echo $productA->name; // 输出: 平板电脑，因为 $productA 看到的也是被修改后的对象
?>

这种“引用传递”的机制在很多情况下是高效且有用的，比如在函数参数传递时，可以避免不必要的内存复制。但当我们确实需要一个完全独立的对象副本，希望对副本的任何修改都不会影响到原始对象时，直接赋值就不能满足需求了。这时候，

clone

关键字就显得至关重要了。它会创建一个全新的盒子，并把原盒子里的东西原封不动地复制一份放进去，这样你就有了两个完全独立的盒子，互不影响。这在我看来，是理解PHP对象操作非常关键的一步。

PHP的

clone

操作是深拷贝还是浅拷贝？深拷贝又该怎么实现？

默认情况下，PHP的

clone

操作执行的是“浅拷贝”（Shallow Copy）。这意味着当一个对象被克隆时，新对象会获得原对象所有属性的副本。对于基本数据类型（如字符串、整数、布尔值等），这些属性值会被直接复制。但对于属性值是另一个对象的情况，

clone

操作只会复制那个嵌套对象的“引用”，而不是创建一个新的嵌套对象副本。

用一个更形象的例子来说：如果你克隆了一个“订单”对象，这个订单对象里包含了一个“客户”对象。浅拷贝的结果是，你会得到一个新的订单对象，但这个新订单对象和旧订单对象仍然共享同一个客户对象。如果你通过新订单修改了客户信息，旧订单的客户信息也会跟着变，这显然不是我们通常期望的“独立副本”。

koly.club

一站式社群管理工具

下载

type = $type; }
}

class Car {
    public $brand;
    public $engine;

    public function __construct($brand, Engine $engine) {
        $this->brand = $brand;
        $this->engine = $engine;
    }
}

$v8Engine = new Engine('V8');
$bmw = new Car('BMW', $v8Engine);

$clonedBmw = clone $bmw; // 浅拷贝

echo "Original BMW Engine Type: " . $bmw->engine->type . "\n"; // V8
echo "Cloned BMW Engine Type: " . $clonedBmw->engine->type . "\n"; // V8

$clonedBmw->engine->type = 'Electric'; // 修改克隆车的引擎类型

echo "Original BMW Engine Type after modification: " . $bmw->engine->type . "\n"; // 输出: Electric！
echo "Cloned BMW Engine Type after modification: " . $clonedBmw->engine->type . "\n"; // 输出: Electric
// 看到没？原始车的引擎类型也变了，这就是浅拷贝的问题。
?>

要实现“深拷贝”（Deep Copy），你需要手动处理那些嵌套的对象。这正是

__clone()

魔术方法发挥作用的地方。在

__clone()

方法内部，你可以遍历对象的属性，如果某个属性是对象，你就需要对这个属性再次执行

clone

操作，从而递归地创建所有嵌套对象的独立副本。

type = $type; }
}

class Car {
    public $brand;
    public $engine;

    public function __construct($brand, Engine $engine) {
        $this->brand = $brand;
        $this->engine = $engine;
    }

    public function __clone() {
        // 在克隆Car对象后，手动克隆其内部的Engine对象
        $this->engine = clone $this->engine;
    }
}

$v8Engine = new Engine('V8');
$bmw = new Car('BMW', $v8Engine);

$clonedBmw = clone $bmw; // 现在会触发Car::__clone()，实现深拷贝

echo "Original BMW Engine Type: " . $bmw->engine->type . "\n"; // V8
echo "Cloned BMW Engine Type: " . $clonedBmw->engine->type . "\n"; // V8

$clonedBmw->engine->type = 'Electric'; // 修改克隆车的引擎类型

echo "Original BMW Engine Type after deep clone modification: " . $bmw->engine->type . "\n"; // 输出: V8 (原始对象未受影响)
echo "Cloned BMW Engine Type after deep clone modification: " . $clonedBmw->engine->type . "\n"; // 输出: Electric
?>

深拷贝的实现可能会变得复杂，特别是当对象图非常深或存在循环引用时。在实际项目中，我们可能还需要考虑序列化/反序列化（

serialize()

和

unserialize()

）来做深拷贝，但这通常伴随着一些性能开销和额外的限制（比如闭包就不能被序列化），所以

__clone()

在大多数情况下是更直接和推荐的做法。

在哪些场景下，克隆对象变得尤为重要？

在我看来，对象克隆并非一个日常操作，但它在某些特定场景下，简直是解决问题的“瑞士军刀”。

保持原始对象状态的纯洁性： 想象你有一个配置对象，它包含了应用程序运行所需的所有设置。你可能需要在程序的某个模块中临时修改一些配置项，但你不希望这些修改影响到其他模块，或者影响到后续的执行。这时，克隆这个配置对象，然后在副本上进行修改，就能完美地保持原始配置的纯净。这在处理一些不可变（immutable）对象时尤其重要，虽然PHP本身没有强制的不可变性，但通过克隆可以模拟这种行为。
实现“原型模式”（Prototype Pattern）： 这是一种创建型设计模式。当你需要创建大量相似但又需要独立修改的对象时，每次都从头
```
new
```
一个对象可能效率不高，或者构造过程很复杂。原型模式建议你先创建一个“原型”对象，然后通过克隆这个原型来生成新的对象实例。这比通过
```
new
```
关键字从头创建对象更灵活，尤其当对象的构造函数参数很多或构造过程涉及复杂逻辑时。比如，一个复杂的报告生成器，你可以先配置好一个基础报告模板对象，然后克隆它，再针对不同的数据源进行微调。
避免意外的副作用： 在复杂的业务逻辑中，一个对象可能被多个不同的组件或函数引用。如果你不小心修改了共享的对象，可能会导致意想不到的错误，而且这种错误往往很难追踪。克隆对象可以有效地“隔离”操作，确保你对一个副本的修改不会波及到其他地方，这大大提高了代码的健壮性和可维护性。我曾经就遇到过因为一个共享的查询条件对象被某个地方修改，导致后续的查询结果完全不对的情况，后来通过克隆解决了。
在链式调用中返回新对象： 有些API设计喜欢使用链式调用（Fluent Interface），例如
```
$query->where('id', 1)->orderBy('name');
```
。如果
```
where
```
或
```
orderBy
```
方法修改的是当前对象自身并返回
```
$this
```
，那么每次调用都会改变同一个对象。但在某些情况下，你可能希望每次链式操作都返回一个基于当前状态的“新”对象，而不是修改当前对象。这时，方法内部就可以先克隆
```
$this
```
，然后在新克隆的对象上进行修改并返回。这常见于一些不可变集合或数据转换库中。