The easiest way to convert an object to a PHP array is to use type conversion (array) $object. For stdClass objects, properties will be converted directly into array key-value pairs; but private or protected property names will be modified, such as \0MyClass\0name. For custom classes, you can manually map properties or use reflection to get common properties. Recursive conversion is required when processing nested objects to ensure that objects at all levels are converted. You can also consider built-in methods such as json_decode(json_encode($object), true) or framework tools such as Laravel's Arr::fromArrayable(). The choice depends on structural complexity and performance requirements.

When you need to convert an object into a PHP array, the most straightforward way is using type casting. Just do (array) $yourObject , and that's it. But there's more under the hood worth knowing, especially when dealing with different types of objects—like standard objects, custom classes, or even nested structures.

How basic casting works

Casting an object to an array in PHP is simple:

 $array = (array) $object;

This works fine for stdClass objects created dynamically, like from JSON decoding. The object properties become keys in the array, and their values ??are preserved.

However, visibility matters. If your object comes from a class with private or protected properties, those will show up in the array but with mangled names. For example, a private property name in a class from MyClass will show as \0MyClass\0name . So if you're seeing weird keys in your array, that's probably why.

Handling custom classes

If you're working with a custom class, blind casting might not give you exactly what you want. That's because casting doesn't respect any magic methods like __toArray() or similar unless you explicitly write logic for them.

You have two options:

• Manually map the properties:

   $array = [
      'name' => $object->name,
      'age' => $object->age,
  ];

• Or use reflection to extract all public properties:

   $reflection = new ReflectionObject($object);
  $properties = $reflection->getProperties(ReflectionProperty::IS_PUBLIC);
  
  $array = [];
  foreach ($properties as $prop) {
      $array[$prop->getName()] = $prop->getValue($object);
  }

Reflection gives you more control, especially if you want to skip certain properties or handle specific types differently.

Dealing with nested objects

If your object has other objects inside (like a User object containing an Address object), casting alone won't fully flatten it. You'll end up with arrays containing objects still.

To avoid this, you need recursion:

 function objectToArray($object) {
    if (!is_object($object)) return $object;

    $array = (array) $object;
    foreach ($array as &$value) {
        $value = objectToArray($value);
    }
    return $array;
}

This function dives into every value and makes sure nested objects also get cast properly. It's especially useful when working with data like decoded JSON or ORM results.

When to consider built-in helpers

PHP has some built-in tools that can help too:

• json_decode(json_encode($object), true) – this converts the object to JSON then back to an array. Works well for serializable objects, but may strip out resources or complex types.
• Laravel's Arr::fromArrayable() or Symfony's normalizers – if you're in a framework, these utilities often simplify things further.

Choose based on context. If performance matters or you know the structure is flat, stick with casting or recursion. If you're deep in a framework or need extra normalization steps, use the helper tools.

Basically that's it.

The above is the detailed content of how to cast an object to a php array. For more information, please follow other related articles on the PHP Chinese website!