get_object_vars() 返回对象在当前作用域可访问的非静态属性数组，仅限公共属性（外部调用时）或包含保护属性（内部调用时），不包括私有属性；与 (array) 转换不同，后者通过名称修饰包含所有属性，而递归转换、Reflection API 或 JsonSerializable 可处理嵌套对象或私有/保护属性，适用于复杂场景。
get_object_vars()
在PHP中是一个相当直接的函数，它的核心作用就是将一个对象的所有公共（public）属性提取出来，然后以关联数组的形式返回。这对于需要快速查看对象内部状态，或者将对象数据用于一些不需要完整对象行为的场景（比如日志记录、API响应）时，非常有用。但需要注意的是，它只处理公共属性，私有（private）和保护（protected）属性是不会被它触及的，这是它一个很重要的局限性。
解决方案
在PHP中，将对象转换为数组，
get_object_vars()
确实是最直接、也是最常被提及的方法之一。它的用法非常简单，你只需要把一个对象作为参数传给它，它就会返回一个包含该对象所有公共属性的关联数组。
<?php
class User {
public $id = 1;
public $name = 'Alice';
protected $email = 'alice@example.com';
private $password = 'secret';
public function getEmail() {
return $this->email;
}
}
$user = new User();
$userData = get_object_vars($user);
print_r($userData);
/*
输出：
Array
(
[id] => 1
[name] => Alice
)
*/
// 如果我们在类内部调用 get_object_vars()
class Admin extends User {
public $role = 'admin';
public function getInternalVars() {
return get_object_vars($this);
}
}
$admin = new Admin();
$adminDataInternal = $admin->getInternalVars();
print_r($adminDataInternal);
/*
输出（在类内部，get_object_vars 可以访问所有可访问的属性，包括protected）：
Array
(
[id] => 1
[name] => Alice
[email] => alice@example.com
[role] => admin
)
*/
?>
从上面的例子可以看出，当
get_object_vars()
在对象外部被调用时，它只会获取公共属性。但如果是在对象内部或者其子类内部调用，它就能访问到当前作用域可访问的所有属性，包括
protected
属性。这在我看来，是一个常常被新手忽略，但又非常关键的细节。它并非简单地“只取public”，而是“取当前作用域可访问的非静态属性”。
然而，
get_object_vars()
也有其明显的不足。它无法处理私有属性，也无法递归地将嵌套在对象中的其他对象转换为数组。这意味着，如果你有一个复杂的数据结构，比如一个
Order
对象里面包含了一个
Customer
对象，
get_object_vars()
只能提取
Order
自身的公共属性，而
Customer
对象本身会作为一个对象值存在于数组中，并不会被自动展开。面对这样的情况，我们就需要一些更灵活的策略了。
立即学习“PHP免费学习笔记（深入）”；
get_object_vars()
登录后复制
登录后复制
登录后复制
登录后复制
登录后复制
登录后复制
登录后复制
登录后复制
登录后复制
登录后复制
登录后复制
登录后复制
登录后复制
登录后复制
登录后复制
get_object_vars()
与
(array)
类型转换，到底有什么不一样？
说实话，这两种方式在 PHP 中都常被用来将对象“看起来”像数组，但它们底层的机制和结果却大相径庭，理解它们之间的差异对于避免一些奇怪的bug至关重要。我个人在初学PHP时，就曾因为混淆这两种方式而踩过坑。
get_object_vars()
，我们前面已经提到了，它会返回一个关联数组，其中包含对象在当前作用域下可访问的非静态属性。这意味着，如果你在对象外部调用它，你只会得到公共属性。如果你在对象内部调用它，你就可以得到公共和保护属性。私有属性除非是在其定义的类内部调用，否则都是不可见的。
而
(array)
类型转换，它的行为就有点“暴力”了。当你把一个对象强制转换为数组时，PHP 会把对象的所有属性，包括公共、保护和私有属性，都转换到数组中。但这里有一个非常重要的细节：私有和保护属性在数组中会进行“名称修饰”（name mangling）。
我们来看个例子：
<?php
class Product {
public $name = 'Laptop';
protected $price = 1200;
private $sku = 'LAP-001';
}
$product = new Product();
echo "--- 使用 get_object_vars() ---/n";
print_r(get_object_vars($product));
/*
输出：
Array
(
[name] => Laptop
)
*/
echo "/n--- 使用 (array) 类型转换 ---/n";
print_r((array) $product);
/*
输出：
Array
(
[name] => Laptop
[*price] => 1200
[ Product sku] => LAP-001
)
*/
?>
从输出你可以清晰地看到区别：
-
get_object_vars()
登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制确实只返回了
name
登录后复制这个公共属性。
-
(array)
登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制类型转换则返回了所有属性。其中
protected
登录后复制登录后复制属性
price
登录后复制前面多了一个
*
登录后复制，而
private
登录后复制属性
sku
登录后复制前面则多了
Product
登录后复制（类名，注意空格）作为前缀。这种名称修饰是PHP为了在数组中区分不同访问修饰符的属性而做的。
所以，在我看来：
- 如果你只需要对象的公共数据，并且希望得到一个干净的关联数组，
get_object_vars()
登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制是更优雅的选择。它尊重了对象的封装性。
- 如果你确实需要访问所有属性（包括私有和保护），并且不介意名称修饰带来的“丑陋”，或者你只是想把对象的所有数据倾倒出来进行调试，那么
(array)
登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制强制类型转换可以快速达到目的。但我个人很少在生产代码中直接使用
(array)
登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制转换来处理业务逻辑，因为这通常意味着你可能在违反对象的封装原则。
如何优雅地将包含私有、保护属性或嵌套对象的复杂对象转换为数组？
当
get_object_vars()
和
(array)
转换都无法满足需求时，尤其是涉及到私有/保护属性，或者更常见的，需要递归处理嵌套对象时，我们就需要更高级的策略了。
1. 针对私有/保护属性：利用 Reflection API
PHP的 Reflection API 是一个非常强大的工具，它允许你在运行时检查类、方法、属性等。通过 Reflection，你可以突破访问修饰符的限制，获取到对象的任何属性。
<?php
class Settings {
public $theme = 'dark';
protected $language = 'en';
private $adminEmail = 'admin@example.com';
}
function objectToArrayWithReflection($obj) {
$reflectionClass = new ReflectionClass($obj);
$properties = $reflectionClass->getProperties();
$array = [];
foreach ($properties as $property) {
$property->setAccessible(true); // 允许访问私有和保护属性
$array[$property->getName()] = $property->getValue($obj);
}
return $array;
}
$settings = new Settings();
$settingsArray = objectToArrayWithReflection($settings);
print_r($settingsArray);
/*
输出：
Array
(
[theme] => dark
[language] => en
[adminEmail] => admin@example.com
)
*/
?>
这种方法非常强大，因为它能完全控制属性的访问。但它的缺点是性能开销相对较大，因为 Reflection 操作本身就比较“重”。所以，我通常只在需要深度内省或序列化整个对象（包括其私有状态）时才考虑它。
2. 针对嵌套对象：递归转换
这是最常见的场景之一。如果你有一个对象，它的某个属性值又是另一个对象，你需要将整个结构都转换为数组。这时候，一个递归函数就显得尤为重要。
<?php
class Address {
public $street = '123 Main St';
public $city = 'Anytown';
}
class Customer {
public $id = 101;
public $name = 'John Doe';
public $address; // 嵌套对象
private $secretKey = 'xyz'; // 私有属性
public function __construct() {
$this->address = new Address();
}
}
function convertObjectToArrayRecursive($obj) {
if (!is_object($obj) && !is_array($obj)) {
return $obj;
}
if (is_object($obj)) {
// 使用 get_object_vars() 获取公共属性
// 如果需要私有/保护属性，这里可以结合 Reflection API
$obj = get_object_vars($obj);
}
// 递归处理数组中的每个元素
return array_map(__FUNCTION__, $obj);
}
$customer = new Customer();
$customerArray = convertObjectToArrayRecursive($customer);
print_r($customerArray);
/*
输出：
Array
(
[id] => 101
[name] => John Doe
[address] => Array
(
[street] => 123 Main St
[city] => Anytown
)
)
*/
?>
这个递归函数巧妙地利用了
get_object_vars()
来处理对象，然后
array_map
自身来处理数组中的嵌套结构。请注意，上面的例子中
convertObjectToArrayRecursive
依然只处理了公共属性，因为
get_object_vars()
的限制。如果你需要递归处理所有属性，你需要将
get_object_vars($obj)
替换为 Reflection API 的逻辑。
3. 利用
json_encode
和
json_decode
这是一种非常便捷，但也有其局限性的方法。
json_encode
会将对象的公共属性序列化为 JSON 字符串，然后
json_decode
可以将其转换回 PHP 数组（或
stdClass
对象）。
<?php
class Article {
public $title = 'PHP Object to Array';
protected $author = 'Jane Doe';
private $views = 1000;
}
$article = new Article();
$jsonString = json_encode($article);
$articleArray = json_decode($jsonString, true); // true 表示返回关联数组
print_r($articleArray);
/*
输出：
Array
(
[title] => PHP Object to Array
)
*/
?>
可以看到，
json_encode
默认也只处理公共属性。如果你的类实现了
JsonSerializable
接口，你可以在
jsonSerialize()
方法中自定义序列化逻辑，包括私有和保护属性。对于嵌套对象，
json_encode
会自动递归处理，这使得它在处理复杂数据结构时非常方便。
<?php
class Author implements JsonSerializable {
public $name = 'Jane Doe';
private $email = 'jane@example.com';
public function jsonSerialize(): mixed {
return [
'name' => $this->name,
'email' => $this->email // 暴露私有属性
];
}
}
class Post implements JsonSerializable {
public $title = 'My Blog Post';
public $author; // 嵌套对象
protected $id = 1;
public function __construct() {
$this->author = new Author();
}
public function jsonSerialize(): mixed {
return [
'id' => $this->id, // 暴露保护属性
'title' => $this->title,
'author' => $this->author // 嵌套对象会自动调用其jsonSerialize
];
}
}
$post = new Post();
$postArray = json_decode(json_encode($post), true);
print_r($postArray);
/*
输出：
Array
(
[id] => 1
[title] => My Blog Post
[author] => Array
(
[name] => Jane Doe
[email] => jane@example.com
)
)
*/
?>
这种方式在我看来，是处理复杂对象序列化到数组（尤其是用于API响应）最优雅且推荐的方式之一，因为它将序列化逻辑封装在对象自身中，符合面向对象的原则。
对象转数组，在实际开发中我遇到过哪些“坑”和最佳实践？
在我的开发生涯中，对象转数组这个操作，看似简单，实则暗藏玄机。踩过不少坑，也总结了一些经验。
常见的“坑”：
-
忘记私有/保护属性的访问限制： 最常见的就是
get_object_vars()
登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制只能获取公共属性，导致数据丢失或不完整。比如，你有一个
User
登录后复制对象，里面
passwordHash
登录后复制是私有属性，直接用
get_object_vars()
登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制转换后，这个关键信息就没了。如果后续逻辑依赖这个数据，就会出问题。
-
嵌套对象未递归处理： 很多时候，对象内部会包含其他对象，如果只是简单地
get_object_vars()
登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制，那么嵌套对象本身还是个对象，而不是一个展开的数组。这在处理复杂的数据结构时，经常会导致前端或下游服务无法正确解析。
-
类型转换的副作用： 使用
(array)
登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制强制类型转换时，私有和保护属性的名称修饰问题，有时会让人摸不着头脑。特别是当你需要通过字符串键来访问这些属性时，需要记住那些奇怪的前缀。
-
json_encode
登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制的默认行为：
虽然json_encode
登录后复制登录后复制登录后复制登录后复制登录后复制登录后复制很方便，但它默认也只处理公共属性。如果你不实现
JsonSerializable
登录后复制登录后复制登录后复制接口，或者不明确指定序列化逻辑，一些关键的非公共数据就可能被忽略。
- 性能考量： 对于非常庞大或深度嵌套的对象，递归转换或 Reflection API 的使用可能会带来一定的性能开销。虽然大多数情况下影响不大，但在高并发或大数据量场景下，这可能成为瓶颈。
- 丢失行为： 对象转换为数组后，就失去了其原有的方法和行为。这听起来是废话，但在某些情况下，开发者可能会不自觉地在数组上尝试调用对象的方法，或者期望数组能表现出对象的某种智能。
最佳实践：
- 明确目的： 在进行对象转数组之前，先问自己：我为什么要转换？我需要哪些数据？是只需要公共数据，还是所有数据？是需要扁平化，还是保留嵌套结构？明确了目的，才能选择最合适的方法。
-
封装序列化逻辑： 对于需要频繁转换为数组的对象，尤其是在API响应或数据传输场景，强烈建议让对象实现
JsonSerializable
登录后复制登录后复制登录后复制接口，并在
jsonSerialize()
登录后复制登录后复制方法中定义其数组表示。这使得序列化逻辑内聚在对象内部，易于维护和理解。
- 使用 DTO（Data Transfer Object）： 如果你的对象结构很复杂，或者你需要将业务逻辑对象转换为一个更简单、扁平化的数据结构进行传输，可以考虑创建专门的 DTO。这些 DTO 通常只包含公共属性，或者通过构造函数、工厂方法从业务对象中提取所需数据。
- 递归函数处理复杂结构： 如果你无法修改原始类（例如，处理第三方库的对象），并且需要递归地将所有属性（包括私有和保护）转换为数组，那么一个结合 Reflection API 的递归函数是你的不二选择。但要记住其性能开销。
- 避免过度转换： 有时候，我们并不需要将整个对象转换为数组。可能只是需要获取对象中的某几个属性。在这种情况下，直接访问属性或者调用对象的 getter 方法会更直接、更高效，也更符合面向对象的原则。
- 考虑数据安全： 在将对象转换为数组用于外部传输时，要特别注意敏感信息的过滤。例如，密码哈希、API 密钥等私有数据，即使通过 Reflection 提取出来，也绝不能轻易暴露。
总的来说，对象转数组是一个非常实用的操作，但绝不是一个“一刀切”的问题。理解不同方法的优缺点，结合实际需求和场景，选择最合适的方案，才能写出健壮、高效且可维护的代码。
以上就是如何在PHP中将对象转为数组？get_object_vars()的正确用法的详细内容，更多请关注php中文网其它相关文章！