如何在PHP中将对象转为数组？get_object_vars()的正确用法

雪夜

发布时间：2025-08-28 11:38:01

763人浏览过

来源于php中文网

原创

get_object_vars() 返回对象在当前作用域可访问的非静态属性数组，仅限公共属性（外部调用时）或包含保护属性（内部调用时），不包括私有属性；与 (array) 转换不同，后者通过名称修饰包含所有属性，而递归转换、Reflection API 或 JsonSerializable 可处理嵌套对象或私有/保护属性，适用于复杂场景。

如何在php中将对象转为数组？get_object_vars()的正确用法

get_object_vars()

在PHP中是一个相当直接的函数，它的核心作用就是将一个对象的所有公共（public）属性提取出来，然后以关联数组的形式返回。这对于需要快速查看对象内部状态，或者将对象数据用于一些不需要完整对象行为的场景（比如日志记录、API响应）时，非常有用。但需要注意的是，它只处理公共属性，私有（private）和保护（protected）属性是不会被它触及的，这是它一个很重要的局限性。

解决方案

在PHP中，将对象转换为数组，

get_object_vars()

确实是最直接、也是最常被提及的方法之一。它的用法非常简单，你只需要把一个对象作为参数传给它，它就会返回一个包含该对象所有公共属性的关联数组。

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()

与

(array)

类型转换，到底有什么不一样？

说实话，这两种方式在 PHP 中都常被用来将对象“看起来”像数组，但它们底层的机制和结果却大相径庭，理解它们之间的差异对于避免一些奇怪的bug至关重要。我个人在初学PHP时，就曾因为混淆这两种方式而踩过坑。

get_object_vars()

，我们前面已经提到了，它会返回一个关联数组，其中包含对象在当前作用域下可访问的非静态属性。这意味着，如果你在对象外部调用它，你只会得到公共属性。如果你在对象内部调用它，你就可以得到公共和保护属性。私有属性除非是在其定义的类内部调用，否则都是不可见的。

而

(array)

类型转换，它的行为就有点“暴力”了。当你把一个对象强制转换为数组时，PHP 会把对象的所有属性，包括公共、保护和私有属性，都转换到数组中。但这里有一个非常重要的细节：私有和保护属性在数组中会进行“名称修饰”（name mangling）。

我们来看个例子：

 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，你可以突破访问修饰符的限制，获取到对象的任何属性。

VISBOOM

AI虚拟试衣间，时尚照相馆。

下载

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. 针对嵌套对象：递归转换

这是最常见的场景之一。如果你有一个对象，它的某个属性值又是另一个对象，你需要将整个结构都转换为数组。这时候，一个递归函数就显得尤为重要。

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 Object to Array
)
*/
?>

可以看到，

json_encode

默认也只处理公共属性。如果你的类实现了

JsonSerializable

接口，你可以在

jsonSerialize()

方法中自定义序列化逻辑，包括私有和保护属性。对于嵌套对象，

json_encode

会自动递归处理，这使得它在处理复杂数据结构时非常方便。

 $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 提取出来，也绝不能轻易暴露。