PHP对象转数组方法：get_object_vars()使用详解

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《PHP对象转数组方法：get_object_vars()使用详解》，这篇文章主要讲到等等知识，如果你对文章相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

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 对象本身会作为一个对象值存在于数组中，并不会被自动展开。面对这样的情况，我们就需要一些更灵活的策略了。

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响应）最优雅且推荐的方式之一，因为它将序列化逻辑封装在对象自身中，符合面向对象的原则。

对象转数组，在实际开发中我遇到过哪些“坑”和最佳实践？

在我的开发生涯中，对象转数组这个操作，看似简单，实则暗藏玄机。踩过不少坑，也总结了一些经验。

常见的“坑”：

1. 忘记私有/保护属性的访问限制： 最常见的就是 get_object_vars() 只能获取公共属性，导致数据丢失或不完整。比如，你有一个 User 对象，里面 passwordHash 是私有属性，直接用 get_object_vars() 转换后，这个关键信息就没了。如果后续逻辑依赖这个数据，就会出问题。
2. 嵌套对象未递归处理： 很多时候，对象内部会包含其他对象，如果只是简单地 get_object_vars()，那么嵌套对象本身还是个对象，而不是一个展开的数组。这在处理复杂的数据结构时，经常会导致前端或下游服务无法正确解析。
3. 类型转换的副作用： 使用 (array) 强制类型转换时，私有和保护属性的名称修饰问题，有时会让人摸不着头脑。特别是当你需要通过字符串键来访问这些属性时，需要记住那些奇怪的前缀。
4. json_encode 的默认行为： 虽然 json_encode 很方便，但它默认也只处理公共属性。如果你不实现 JsonSerializable 接口，或者不明确指定序列化逻辑，一些关键的非公共数据就可能被忽略。
5. 性能考量： 对于非常庞大或深度嵌套的对象，递归转换或 Reflection API 的使用可能会带来一定的性能开销。虽然大多数情况下影响不大，但在高并发或大数据量场景下，这可能成为瓶颈。
6. 丢失行为： 对象转换为数组后，就失去了其原有的方法和行为。这听起来是废话，但在某些情况下，开发者可能会不自觉地在数组上尝试调用对象的方法，或者期望数组能表现出对象的某种智能。

最佳实践：

1. 明确目的： 在进行对象转数组之前，先问自己：我为什么要转换？我需要哪些数据？是只需要公共数据，还是所有数据？是需要扁平化，还是保留嵌套结构？明确了目的，才能选择最合适的方法。
2. 封装序列化逻辑： 对于需要频繁转换为数组的对象，尤其是在API响应或数据传输场景，强烈建议让对象实现 JsonSerializable 接口，并在 jsonSerialize() 方法中定义其数组表示。这使得序列化逻辑内聚在对象内部，易于维护和理解。
3. 使用 DTO（Data Transfer Object）： 如果你的对象结构很复杂，或者你需要将业务逻辑对象转换为一个更简单、扁平化的数据结构进行传输，可以考虑创建专门的 DTO。这些 DTO 通常只包含公共属性，或者通过构造函数、工厂方法从业务对象中提取所需数据。
4. 递归函数处理复杂结构： 如果你无法修改原始类（例如，处理第三方库的对象），并且需要递归地将所有属性（包括私有和保护）转换为数组，那么一个结合 Reflection API 的递归函数是你的不二选择。但要记住其性能开销。
5. 避免过度转换： 有时候，我们并不需要将整个对象转换为数组。可能只是需要获取对象中的某几个属性。在这种情况下，直接访问属性或者调用对象的 getter 方法会更直接、更高效，也更符合面向对象的原则。
6. 考虑数据安全： 在将对象转换为数组用于外部传输时，要特别注意敏感信息的过滤。例如，密码哈希、API 密钥等私有数据，即使通过 Reflection 提取出来，也绝不能轻易暴露。

总的来说，对象转数组是一个非常实用的操作，但绝不是一个“一刀切”的问题。理解不同方法的优缺点，结合实际需求和场景，选择最合适的方案，才能写出健壮、高效且可维护的代码。

文中关于对象转数组,对象属性,JsonSerializable,get_object_vars(),ReflectionAPI的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《PHP对象转数组方法：get_object_vars()使用详解》文章吧，也可关注golang学习网公众号了解相关技术文章。