PHP对象转数组：从基础方法到高级技巧，深度解析与最佳实践127

在PHP开发中，对象与数组是两种最基本且最常用的数据结构。对象通常用于封装数据和行为，体现面向对象的编程思想；而数组则以其灵活的键值对形式，在数据存储、处理以及与外部系统（如API、数据库）交互时扮演着不可或缺的角色。在实际项目开发中，我们经常会遇到需要将PHP对象转换为数组的场景，例如：
将ORM查询结果转换为数组，以便于前端展示或API响应。
将配置对象转换为数组，便于序列化或存储。
在调试过程中，将复杂对象转化为数组以便查看其内部状态。
与不支持对象的遗留系统或库进行数据交换。

本文将作为一篇专业的程序员指南，深入探讨PHP中将对象转换为数组的各种方法，从基础的类型转换到高级的反射API，并分析每种方法的特点、适用场景、性能考量以及最佳实践，旨在帮助开发者根据具体需求选择最合适的数据转换策略。

一、基础转换方法：快速但有局限性

1.1 强制类型转换 `(array)`

这是最直接、最简洁的将对象转换为数组的方法。通过在对象变量前加上 `(array)` 关键字，PHP会尝试将其转换为一个数组。

工作原理：

当一个对象被强制转换为数组时，它的所有可访问的（即 `public`）属性都将成为数组的元素，属性名作为数组的键。需要注意的是，这种方法不会转换 `protected` 和 `private` 属性。<?php
class User {
public $name = '张三';
protected $age = 30;
private $email = 'zhangsan@';
public function __construct($name, $age, $email) {
$this->name = $name;
$this->age = $age;
$this->email = $email;
}
public function getAge() {
return $this->age;
}
}
$user = new User('李四', 25, 'lisi@');
$userArray = (array) $user;
echo "<pre>";
print_r($userArray);
echo "</pre>";
/* 输出:
Array
(
[name] => 李四
)
*/
?>

从上面的例子可以看出，只有 `public $name` 属性被转换了。`protected` 和 `private` 属性被忽略。

适用场景：
对象结构简单，且只需要获取其公共属性时。
快速调试，只关注对象的公共可访问部分。

局限性：
无法获取 `protected` 和 `private` 属性。
对嵌套对象不会进行递归转换，只会将嵌套对象本身作为数组的一个值。

1.2 `get_object_vars()` 函数

`get_object_vars()` 函数返回一个由对象属性组成的关联数组。其行为与强制类型转换非常相似，但在某些特定上下文中有细微区别。

工作原理：

当从对象外部调用 `get_object_vars()` 时，它会返回所有可访问的（`public`）属性。与 `(array)` 强制转换一样，它不会返回 `protected` 和 `private` 属性。

然而，如果在一个对象的内部方法中调用 `get_object_vars($this)`，它将返回该对象的所有属性，包括 `public`、`protected` 和 `private`。这使得它在对象内部需要全面访问自身属性时非常有用。<?php
class Product {
public $name;
protected $price;
private $sku;
public function __construct($name, $price, $sku) {
$this->name = $name;
$this->price = $price;
$this->sku = $sku;
}
// 在对象内部调用 get_object_vars()
public function toArrayInternal() {
return get_object_vars($this);
}
}
$product = new Product('笔记本电脑', 999.99, 'LT001');
// 从外部调用 get_object_vars()
$externalArray = get_object_vars($product);
echo "外部调用 get_object_vars():<pre>";
print_r($externalArray);
echo "</pre>";
/* 输出:
外部调用 get_object_vars():Array
(
[name] => 笔记本电脑
)
*/
// 从内部方法调用 get_object_vars()
$internalArray = $product->toArrayInternal();
echo "内部调用 get_object_vars():<pre>";
print_r($internalArray);
echo "</pre>";
/* 输出:
内部调用 get_object_vars():Array
(
[name] => 笔记本电脑
[price] => 999.99
[sku] => LT001
)
*/
?>

适用场景：
需要获取对象公共属性时（与 `(array)` 类似）。
在对象内部需要获取其所有属性（包括 `protected` 和 `private`）进行处理时。

局限性：
从外部调用时，仍无法获取 `protected` 和 `private` 属性。
对嵌套对象不会进行递归转换。

二、高级转换方法：灵活与深度

2.1 `json_encode()` 和 `json_decode()` (JSON 转换)

利用JSON的序列化和反序列化机制是实现对象深度转换为数组的常用方法。这种方法能够处理嵌套对象，并生成一个完全扁平化的关联数组结构。

工作原理：

首先，使用 `json_encode()` 将PHP对象序列化为一个JSON字符串。`json_encode()` 默认只会编码对象的 `public` 属性。如果对象实现了 `JsonSerializable` 接口，`json_encode()` 会调用其 `jsonSerialize()` 方法来获取要序列化的数据。
然后，使用 `json_decode()` 将JSON字符串反序列化为一个PHP数组（当第二个参数为 `true` 时）。<?php
class Address implements JsonSerializable {
public $street;
public $city;
private $zipCode; // private属性
public function __construct($street, $city, $zipCode) {
$this->street = $street;
$this->city = $city;
$this->zipCode = $zipCode;
}
// 实现 JsonSerializable 接口，控制 JSON 序列化行为
public function jsonSerialize(): mixed {
return [
'street' => $this->street,
'city' => $this->city,
'zip_code' => $this->zipCode // 可以选择性暴露 private 属性
];
}
}
class Person {
public $name;
protected $age; // protected属性
public $address;
public function __construct($name, $age, Address $address) {
$this->name = $name;
$this->age = $age;
$this->address = $address;
}
}
$address = new Address('科技路', '北京', '100000');
$person = new Person('王五', 40, $address);
// 直接使用 json_encode() & json_decode()
$jsonString = json_encode($person); // Person 类的 protected $age 不会被编码
$personArray = json_decode($jsonString, true);
echo "JSON 转换:<pre>";
print_r($personArray);
echo "</pre>";
/* 输出:
JSON 转换:Array
(
[name] => 王五
[address] => Array
(
[street] => 科技路
[city] => 北京
[zip_code] => 100000
)
)
*/
?>

从输出可以看到，`Person` 类的 `protected $age` 属性没有被转换，但 `Address` 类因为实现了 `JsonSerializable` 接口，其 `private $zipCode` 属性在 `jsonSerialize()` 方法中被选择性地暴露出来了。

适用场景：
需要深度转换对象（包括嵌套对象）时。
准备API响应数据，与JavaScript等前端应用交互时。
对象实现了 `JsonSerializable` 接口，需要自定义序列化逻辑时。
希望在转换过程中过滤掉某些属性，或更改属性名时。

优势：
支持递归深度转换。
具有良好的兼容性，因为JSON是跨语言的数据格式。
可以通过 `JsonSerializable` 接口灵活控制序列化内容。

局限性：
默认只处理 `public` 属性，除非实现 `JsonSerializable` 接口。
性能开销相对较高，因为涉及到字符串的序列化和反序列化。
所有数据类型都会被转换成JSON的对应类型（例如，所有数字都变成JSON数字，浮点数精度可能受影响）。

2.2 Reflection API (反射机制)

PHP的反射API提供了一种强大的机制，允许程序在运行时检查类、方法和属性。通过反射，我们可以访问到对象的任何属性，包括 `public`、`protected` 和 `private`，从而实现最彻底的对象到数组的转换。

工作原理：

通过 `ReflectionClass` 类，我们可以获取一个类的所有属性（`ReflectionProperty` 对象）。对于每个 `ReflectionProperty` 对象，我们可以使用 `setAccessible(true)` 方法使其可访问，无论其原始访问修饰符是什么，然后通过 `getValue()` 获取属性值。<?php
class Employee {
public $firstName;
protected $lastName;
private $salary;
private $department;
public $contractType;
public function __construct($firstName, $lastName, $salary, $department, $contractType) {
$this->firstName = $firstName;
$this->lastName = $lastName;
$this->salary = $salary;
$this->department = $department;
$this->contractType = $contractType;
}
public function getSalary() {
return $this->salary;
}
}
function objectToArrayWithReflection($obj) {
$arr = [];
$reflectionClass = new ReflectionClass($obj);
$properties = $reflectionClass->getProperties(); // 获取所有属性
foreach ($properties as $property) {
$property->setAccessible(true); // 设置为可访问
$value = $property->getValue($obj);
// 递归处理嵌套对象
if (is_object($value)) {
$arr[$property->getName()] = objectToArrayWithReflection($value);
} else {
$arr[$property->getName()] = $value;
}
}
return $arr;
}
$employee = new Employee('张', '小明', 8000, '研发部', '全职');
$employeeArray = objectToArrayWithReflection($employee);
echo "反射转换:<pre>";
print_r($employeeArray);
echo "</pre>";
/* 输出:
反射转换:Array
(
[firstName] => 张
[lastName] => 小明
[salary] => 8000
[department] => 研发部
[contractType] => 全职
)
*/
?>

适用场景：
需要获取对象所有属性（包括 `public`、`protected` 和 `private`）进行转换时。
开发通用序列化库、ORM框架或调试工具时。
当对象不便修改（例如来自第三方库），但又需要完全访问其内部数据时。

优势：
提供对对象内部结构的完全控制，可以访问所有属性。
支持深度递归转换。

局限性：
性能开销最高，因为涉及复杂的运行时检查。
代码相对复杂和冗长。
可能会破坏封装性，需要谨慎使用。

2.3 自定义 `toArray()` 方法或模式

对于您自己定义的类，最优雅、最可控的解决方案是在对象内部定义一个 `toArray()` 方法。这种方法将转换逻辑封装在对象本身，使其成为对象行为的一部分。

工作原理：

在类中定义一个公共方法，例如 `toArray()`。在该方法中，手动构建并返回一个表示对象当前状态的数组。您可以根据业务逻辑选择性地包含或排除属性，甚至可以对属性值进行格式化或计算。对于嵌套对象，可以在其 `toArray()` 方法中递归调用子对象的 `toArray()`。<?php
class AddressCustom {
public $street;
public $city;
private $zipCode;
public function __construct($street, $city, $zipCode) {
$this->street = $street;
$this->city = $city;
$this->zipCode = $zipCode;
}
public function toArray(): array {
return [
'street' => $this->street,
'city' => $this->city,
// 可以在这里选择性地暴露或隐藏私有属性
'postal_code' => $this->zipCode
];
}
}
class UserCustom {
public $id;
public $username;
protected $passwordHash; // 不希望暴露
private $createdAt; // 不希望暴露
public $address;
public function __construct($id, $username, $passwordHash, $createdAt, AddressCustom $address) {
$this->id = $id;
$this->username = $username;
$this->passwordHash = $passwordHash;
$this->createdAt = $createdAt;
$this->address = $address;
}
public function toArray(): array {
return [
'id' => $this->id,
'username' => $this->username,
// 'password_hash' => $this->passwordHash, // 不暴露
// 'created_at' => $this->createdAt, // 不暴露
'address' => $this->address->toArray() // 递归调用嵌套对象的 toArray()
];
}
}
$address = new AddressCustom('自由大道', '上海', '200000');
$user = new UserCustom(1, 'foobar', 'some_hash_value', '2023-01-01', $address);
$userArray = $user->toArray();
echo "自定义 toArray() 转换:<pre>";
print_r($userArray);
echo "</pre>";
/* 输出:
自定义 toArray() 转换:Array
(
[id] => 1
[username] => foobar
[address] => Array
(
[street] => 自由大道
[city] => 上海
[postal_code] => 200000
)
)
*/
?>

适用场景：
这是推荐的方案，适用于您有权修改类定义的所有情况。
需要对转换过程进行精细控制，例如只暴露特定属性、对属性值进行格式化或计算。
需要支持深度递归转换。

优势：
最佳实践： 将转换逻辑封装在对象内部，符合面向对象原则。
高度可控： 可以自由选择包含或排除哪些属性，以及如何处理属性值。
易于维护： 转换逻辑与类紧密耦合，修改和维护方便。
性能好： 避免了反射和JSON序列化的额外开销。

局限性：
需要手动为每个类编写 `toArray()` 方法，增加了代码量（但通常这种付出是值得的）。
无法用于无法修改源代码的第三方库对象。

2.4 `iterator_to_array()` (迭代器转换)

如果你的对象实现了 `Iterator` 或 `IteratorAggregate` 接口，这意味着它是一个可迭代的对象（通常用于表示集合或列表），那么可以使用 `iterator_to_array()` 函数将其转换为数组。

工作原理：

`iterator_to_array()` 函数会遍历一个迭代器，并将其所有元素存储到一个数组中。<?php
class MyCollection implements IteratorAggregate {
private $items = [];
public function __construct(array $initialItems) {
$this->items = $initialItems;
}
public function addItem($item) {
$this->items[] = $item;
}
public function getIterator(): Traversable {
return new ArrayIterator($this->items);
}
}
$collection = new MyCollection(['Apple', 'Banana']);
$collection->addItem('Orange');
$collectionArray = iterator_to_array($collection);
echo "迭代器转换:<pre>";
print_r($collectionArray);
echo "</pre>";
/* 输出:
迭代器转换:Array
(
[0] => Apple
[1] => Banana
[2] => Orange
)
*/
?>

适用场景：
对象本质上是数据集合或列表，并实现了迭代器接口。

局限性：
不适用于普通的数据封装对象，只适用于可迭代对象。
通常转换为索引数组，而不是基于对象属性的关联数组。

三、深度探讨与最佳实践

3.1 浅拷贝 vs. 深拷贝

在对象转数组时，一个重要的概念是“深拷贝”和“浅拷贝”。
浅拷贝： 只复制对象的第一层属性。如果属性值是另一个对象，复制的是该对象的引用，而不是一个新的独立对象。当修改数组中的嵌套对象时，原始对象中的嵌套对象也会被修改。`(array)` 强制转换和 `get_object_vars()` 都是浅拷贝。
深拷贝： 递归地复制所有属性，包括嵌套对象。修改数组中的嵌套对象不会影响原始对象。`json_encode()/json_decode()` 默认实现深拷贝（因为数据被序列化成字符串后再反序列化），自定义 `toArray()` 方法如果也递归调用子对象的 `toArray()`，则可以实现深拷贝。反射方法也需要手动实现递归才能达到深拷贝效果。

根据需求选择是进行浅拷贝还是深拷贝非常重要。如果数据结构复杂且可能修改，通常推荐深拷贝。

3.2 性能考量

`(array)` 强制转换和 `get_object_vars()`： 性能最高，因为它们是PHP语言级别的原生操作，且只处理第一层公共属性。
自定义 `toArray()` 方法： 性能次之，其效率取决于你在方法中实现的逻辑复杂性。由于没有额外的序列化/反射开销，通常比JSON和反射快。
`json_encode()/json_decode()`： 性能居中，涉及到字符串的序列化和反序列化，会有一定的开销，但在处理复杂结构和跨语言通信时是可接受的。
Reflection API： 性能最低，因为它需要在运行时进行复杂的元数据查找和操作。应避免在高性能要求的循环中频繁使用。

在性能敏感的场景，应优先考虑使用 `(array)`、`get_object_vars()` 或自定义 `toArray()`。如果需要深度转换且性能不是瓶颈，`json_encode()/json_decode()` 是一个很好的平衡点。

3.3 场景选择指南

最常用/推荐：

自定义 `toArray()` 方法： 当您控制类定义时，这是最灵活、最可控、最符合面向对象原则的方案。适用于API响应、数据持久化等需要精细控制输出的场景。


快速查看/简单对象：

`(array)` 强制转换： 仅需获取对象的公共属性，且对象不含嵌套结构时，最快捷。
`get_object_vars()`： 同上。但若在对象内部需要获取所有属性，它更为强大。


深度转换/API交互：

`json_encode()` 和 `json_decode()`： 当需要将复杂嵌套对象完全转换为关联数组，并可能用于API响应或存储时，这是强大的选择。利用 `JsonSerializable` 接口可实现自定义逻辑。


高级/特殊需求：

Reflection API： 当需要访问对象的 `protected` 或 `private` 属性，且无法修改类定义（例如第三方库），或者开发通用序列化工具时。
`iterator_to_array()`： 当处理的是实现了迭代器接口的集合对象时。

3.4 推荐使用接口增强可维护性

为了提高代码的一致性和可维护性，可以考虑定义一个接口，要求所有需要转换为数组的对象都实现该接口：<?php
interface ToArrayInterface {
public function toArray(): array;
}
class UserProfile implements ToArrayInterface {
public $id;
public $name;
private $secret;
public function __construct($id, $name, $secret) {
$this->id = $id;
$this->name = $name;
$this->secret = $secret;
}
public function toArray(): array {
return [
'id' => $this->id,
'name' => $this->name
// 刻意隐藏 $secret
];
}
}
class Post implements ToArrayInterface {
public $title;
public $content;
public $author; // UserProfile 对象
public function __construct($title, $content, UserProfile $author) {
$this->title = $title;
$this->content = $content;
$this->author = $author;
}
public function toArray(): array {
return [
'title' => $this->title,
'content' => $this->content,
'author' => $this->author->toArray() // 递归调用
];
}
}
$user = new UserProfile(1, '张三丰', '武当秘籍');
$post = new Post('太极拳入门', '太极拳是一种...', $user);
$postArray = $post->toArray();
echo "接口增强的 toArray():<pre>";
print_r($postArray);
echo "</pre>";
/* 输出:
接口增强的 toArray():Array
(
[title] => 太极拳入门
[content] => 太极拳是一种...
[author] => Array
(
[id] => 1
[name] => 张三丰
)
)
*/
?>

这样，任何实现了 `ToArrayInterface` 的对象都保证提供了 `toArray()` 方法，增强了类型安全性，也方便统一处理。

四、总结

PHP提供了多种将对象转换为数组的方法，每种方法都有其独特的优点和适用场景。作为专业的程序员，我们应该根据实际需求，综合考虑数据封装性、访问权限、性能、代码可读性和可维护性来选择最合适的转换策略。
对于简单对象或内部调试，`(array)` 强制转换和 `get_object_vars()` 是快速便捷的选择。
对于API响应或跨系统数据交换，`json_encode()` 和 `json_decode()` 提供了强大而通用的深度转换能力。
对于需要完全控制转换逻辑、注重封装性和可维护性的自有类，自定义 `toArray()` 方法是首选的最佳实践。
对于复杂框架开发或访问第三方库私有数据的特殊场景，反射API提供了终极的灵活性和控制力。

理解这些方法的内在机制和局限性，将使您能够更有效地处理PHP中的数据转换任务，构建出健壮、高效且易于维护的应用程序。

2026-02-26

---

上一篇：PHP高效安全批量文件上传：从基础到高级实践

下一篇：PHP数据库UPDATE操作：安全更新、结果确认与相关ID信息的高效获取