Convert a PHP object to an associative array

Question

I'm integrating an API to my website which works with data stored in objects while my code is written using arrays.

I'd like a quick-and-dirty function to convert an object to an array.

Kasey

Answer 1

Just typecast it

$array = (array) $yourObject;

From Arrays:

If an object is converted to an array, the result is an array whose elements are the object's properties. The keys are the member variable names, with a few notable exceptions: integer properties are unaccessible; private variables have the class name prepended to the variable name; protected variables have a '*' prepended to the variable name. These prepended values have null bytes on either side.

Example: Simple Object

$object = new StdClass;
$object->foo = 1;
$object->bar = 2;

var_dump( (array) $object );

Output:

array(2) {
  'foo' => int(1)
  'bar' => int(2)
}

Example: Complex Object

class Foo
{
    private $foo;
    protected $bar;
    public $baz;

    public function __construct()
    {
        $this->foo = 1;
        $this->bar = 2;
        $this->baz = new StdClass;
    }
}

var_dump( (array) new Foo );

Output (with \0s edited in for clarity):

array(3) {
  '\0Foo\0foo' => int(1)
  '\0*\0bar' => int(2)
  'baz' => class stdClass#2 (0) {}
}

Output with var_export instead of var_dump:

array (
  '' . "\0" . 'Foo' . "\0" . 'foo' => 1,
  '' . "\0" . '*' . "\0" . 'bar' => 2,
  'baz' =>
  stdClass::__set_state(array(
  )),
)

To know more about php built-in class stdclass. You can read this documentation

Typecasting this way will not do deep casting of the object graph and you need to apply the null bytes (as explained in the manual quote) to access any non-public attributes. So this works best when casting StdClass objects or objects with only public properties. For quick and dirty (what you asked for) it's fine.

Also see this in-depth blog post:

• Fast PHP Object to Array conversion

Melodeemelodeon

Ha, and I found a use for it already - see my answer to #4352703 – Decretive

Also consider the ArrayAccess interface, perhaps in combination with this solution. php.net/manual/en/class.arrayaccess.php – Telegraphese

This will fail, if the object contains sub object which point back to the object which we are going to convert. This will cause an infinit loop. – Suazo

It you have integer keys the'll be converted in to string and this can cause big issue. E.g. [1 => "one"] becomes ["1" => "one"] – Sidhu

@Sidhu objects having numeric properties is a codesmell on it's own. – Melodeemelodeon

@Melodeemelodeon and how to convert it back to Collection Object? – Cassation

@Cassation to a StdClass object: (object) $array. Typecasting to any other object requires hackery: #3244400 – Melodeemelodeon

@Howie Typecasting with (array) and (object) works reliably and the same across all versions since PHP 4.3. See 3v4l.org/X6lhm. If you get a syntax error, you did something wrong. – Melodeemelodeon

@Melodeemelodeon if (!empty((array)$object)) on 5.3.28 generated an error, whilst the same thing on 5.5.x works just fine. I will inspect further, if I find the time. – Incontrovertible

@Incontrovertible see the Changelog section for empty. You cannot use an expression with empty prior to 5.5. This is completely unrelated to typecasting ;) – Melodeemelodeon

@Melodeemelodeon Heh, so that was it. I'll leave my comments for future notice. Thanks! – Incontrovertible

Attention!!! Integer properties become unaccessible. Though they can be seen via print_r etc. – Downs

@Vishnja Integer properties are not allowed in PHP. The only way to get them without causing an error is by json_decoding something like {"0": 42} in which case you can still access them by $obj->{"0"} – Melodeemelodeon

@Melodeemelodeon Yes, exactly. This brings confusion when somebody recieves object from some API, that really should be an array, decodes and converts it. And finally sees array elements but can not access them. – Downs

@Vishnja well, you can access them. Like I said $obj->{"0"} will work :) – Melodeemelodeon

does typecasting like this (array) $object ensure that the order in which the object attributes are assigned is maintained in the resulting array? – Bullnose

Not a good solution! It does not deep convert objects to arrays, which will NOT be acceptable when working with APIs (it might work for the most simple examples, but it won't otherwise). Why do people upvote this? – Iambus

@LidelnKyoku because the OP asked for a quick and dirty solution and the answer clearly states that it's not deep converting. And I guess it solves the problem for most people that had the problem ¯\_(ツ)_/¯ – Melodeemelodeon

Still there @Melodeemelodeon ?! :) Yeah it does work in the most simple scenarios, but it won't otherwise, which means taking a risk (unless the user is 100% sure of what the API will return today and in the future). It's an accident waiting to happen IMHO. Anyway, stay safe, cheers Gordon! :) – Iambus

OP asked for a quick-and-dirty solution, he got one. Thing is there is no problem having a problem in this solution. – Incivility

This does not work recursively. You will still have Objects serialized the descendant values if you use this method. – Yaekoyael

@Yaekoyael see above. The answer clearly states that it will not do deep casting. – Melodeemelodeon

Answer 2

You can quickly convert deeply nested objects to associative arrays by relying on the behavior of the JSON encode/decode functions:

$array = json_decode(json_encode($nested_object), true);

Nonobedience

This is the best solution if you want a full depth recursive conversion (and of course dont mind the bad performance) – Nguyen

BTW this does not seem to work anymore on php 5.5, you will get back an array of objects again – Evasive

Respectfully, I think it does still work... don't forget to set the 2nd parameter to true. – Clemmie

The second parameter solved the problem, working for PHP 5.6.25. Thanks! – Overby

returns false when you have a binary value – Psi

@sics(, @Psi ): You can control what to (also: how to) export by implementing JsonSerializable into your class: php.net/manual/en/class.jsonserializable.php – Virga

NOTE: this might cause endless loop and out of memory error – Collapse

@EliaWeiss Have an example to demonstrate that? – Nonobedience

@KirkB I can confirm this solution works perfectly with nested objects in PHP 7.4.14, while casting to array using $arr = (array) $obj; does not. – Crippen

It didn't work for me, but I added symphony as mentioned in the post below and worked. – Mellar

This will break if there are any special characters in the field values. – Janessajanet

@PabloPazos Do you have an example code snippet that breaks? JSON should encode/decode UTF-8 characters without an issue. – Nonobedience

Answer 3

From the first Google hit for "PHP object to assoc array" we have this:

/**
 * @param array|object $data
 * @return array
 */
function object_to_array($data)
{
    $result = [];
    foreach ($data as $key => $value)
    {
        $result[$key] = (is_array($value) || is_object($value)) ? object_to_array($value) : $value;
    }
    return $result;
}

The original source was from codesnippets.joyent.com and has been changed according to @SpYk3HH's comment; see also Object Iteration.

---

To compare it to the solution of json_decode & json_encode, this one seems faster. Here is a random benchmark (using the simple time measuring):

$obj = (object) [
    'name'    =>'Mike',
    'surname' =>'Jovanson',
    'age'     =>'45',
    'time'    =>1234567890,
    'country' =>'Germany',
];

##### 100 000 cycles ######
* json_decode(json_encode($var))   : 4.15 sec
* object_to_array($var)            : 0.93 sec

Foss

Personally, I don't like the idea of recalling the function for every value. I have a similar version, but in 3 lines: function objectToArray($o) { $a = array(); foreach ($o as $k => $v) $a[$k] = (is_array($v) || is_object($v)) ? objectToArray($v): $v; return $a; } This just sets anything that's not an object or array and continues on without repetitive recall to the method unless necessary. – Ninon

@SpYk3HH: write your own answer? – Bluegrass

First hit for "php object to assoc array" is #4346054 – Doall

This (and the version from @SpYk3HH) seems to perform even slower for me than the json_encode option (https://mcmap.net/q/53203/-convert-a-php-object-to-an-associative-array). I don't know why these approaches would ever be preferable. – Cutlery

@Cutlery json encode and decode won't work with NaN and INFINITE values for float and potentially may have other issues I can't think of from the top of my head but for many cases it might be a better option. As for optimization, what it needs is context - let me plug a post I wrote on this subject evidentlycube.com/blog/game-optimization/when-to-optimize. the tl;dr being, don't optimize things that don't take huge chunk of the running time because the benefits are meaningless in the context of the whole application. – Vanquish

@Vanquish I agree with your summarized recommendation against needless optimization, but in my case, I only discovered how slow json encode and decode were because they were noticeably slowing down my page load times. So I needed to find a faster way. My new approach is that I pulled json encode and decode out of a loop so that I run them just once outside and then run a loop on their components. – Cutlery

@Ninon your approach integrated into answer. – Foss

Doesn't seem to work with private fields – Janessajanet

Answer 4

If your object properties are public you can do:

$array =  (array) $object;

If they are private or protected, they will have weird key names on the array. So, in this case you will need the following function:

function dismount($object) {
    $reflectionClass = new ReflectionClass(get_class($object));
    $array = array();
    foreach ($reflectionClass->getProperties() as $property) {
        $property->setAccessible(true);
        $array[$property->getName()] = $property->getValue($object);
        $property->setAccessible(false);
    }
    return $array;
}

Pippo

If your property is protected, will setAccessible(false) change it back to protected visibility? or will it make it private? – Ehudd

The only solution I found, that worked with protected properties. Thanks – Dunfermline

best solution for private and protected variables!! – Lemonade

Here the line $property->setAccessible(false); will be executed on every property - even if it was public... – Androus

I suppose another approach would be to cast it as array, then strip the text prefix off the Private properties. A little less dangerous, as your method risks setting public properties private – Hrutkay

not recursive, an object with a couple of levels of associated objects will just convert the top ones and not the associated objects – Janessajanet

Answer 5

What about get_object_vars($obj)? It seems useful if you only want to access the public properties of an object.

See get_object_vars.

Invitation

Answer 6

class Test{
    const A = 1;
    public $b = 'two';
    private $c = test::A;

    public function __toArray(){
        return call_user_func('get_object_vars', $this);
    }
}

$my_test = new Test();
var_dump((array)$my_test);
var_dump($my_test->__toArray());

Output

array(2) {
    ["b"]=>
    string(3) "two"
    ["Testc"]=>
    int(1)
}
array(1) {
    ["b"]=>
    string(3) "two"
}

Tommy

Pro and cons of this solution? What about a class declared as class Test { const A = 1; public $parent = new Test(); } – Snood

Answer 7

Here is some code:

function object_to_array($data) {
    if ((! is_array($data)) and (! is_object($data)))
        return 'xxx'; // $data;

    $result = array();

    $data = (array) $data;
    foreach ($data as $key => $value) {
        if (is_object($value))
            $value = (array) $value;
        if (is_array($value))
            $result[$key] = object_to_array($value);
        else
            $result[$key] = $value;
    }
    return $result;
}

Echinoderm

works best for me (but I needed to remove the 'xxx' and return $data) – Poyang

Answer 8

Type cast your object to an array.

$arr =  (array) $Obj;

It will solve your problem.

Specification

No, it won't, if you have private or protected properties. – Mateo

Answer 9

All other answers posted here are only working with public attributes. Here is one solution that works with JavaBeans-like objects using reflection and getters:

function entity2array($entity, $recursionDepth = 2) {
    $result = array();
    $class = new ReflectionClass(get_class($entity));
    foreach ($class->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
        $methodName = $method->name;
        if (strpos($methodName, "get") === 0 && strlen($methodName) > 3) {
            $propertyName = lcfirst(substr($methodName, 3));
            $value = $method->invoke($entity);

            if (is_object($value)) {
                if ($recursionDepth > 0) {
                    $result[$propertyName] = $this->entity2array($value, $recursionDepth - 1);
                }
                else {
                    $result[$propertyName] = "***";  // Stop recursion
                }
            }
            else {
                $result[$propertyName] = $value;
            }
        }
    }
    return $result;
}

Androus

Yea, but ... if you're using the Object/Array as a variable, which is what all this leads too, why do you need anything other than the public properties? – Ninon

@SpYk3HH: I did not ask the question. I don't even know why anyone would prefer an array over an object in the first place. – Androus

Eh, I often prefer to convert query results to array just to provide a uniform "list" for looping through, as most other thing in an app that must be "looped" tend to be arrays. Just makes it easy to write "universal loop methods". Often, if i'm making use of an object, I'm not looping through it's properties, I'm using it as an object and using those properties as needed. – Ninon

"why anyone would prefer an array over an object" I want to write a method, which loops with foreach through the values of an object's properties to write them in an excel file. I want this method to be independent of the object so I can use it with different arrays. Therefore my object needs a _toArray() method – Kathernkatheryn

Answer 10

To convert an object into array just cast it explicitly:

$name_of_array = (array) $name_of_object;

Cosmorama

This should get the upvotes. The best answer. – Optimism

Answer 11

Use:

function readObject($object) {
    $name = get_class ($object);
    $name = str_replace('\\', "\\\\", $name); // Outcomment this line, if you don't use
                                              // class namespaces approach in your project
    $raw = (array)$object;

    $attributes = array();
    foreach ($raw as $attr => $val) {
        $attributes[preg_replace('('.$name.'|\*|)', '', $attr)] = $val;
    }
    return $attributes;
}

It returns an array without special characters and class names.

Abomasum

I never recommend using parentheses as pattern delimiters. It too easily tricks the eye of developers/reviewers – Nikitanikki

@Abomasum \u0000\u0000 is appearing with property names – Anchor

Answer 12

You can also create a function in PHP to convert an object array:

function object_to_array($object) {
    return (array) $object;
}

Carbamidine

I don't think that wrapping pre-existing solutions on this page as a custom function adds much value to this page. If I am being honest, I think it adds unnecessary bloat to an already bloated page. – Nikitanikki

Answer 13

You can easily use this function to get the result:

function objetToArray($adminBar){
    $reflector = new ReflectionObject($adminBar);
    $nodes = $reflector->getProperties();
    $out = [];
    foreach ($nodes as $node) {
        $nod = $reflector->getProperty($node->getName());
        $nod->setAccessible(true);
        $out[$node->getName()] = $nod->getValue($adminBar);
    }
    return $out;
}

Use PHP 5 or later.

Circulate

Answer 14

Here is my recursive PHP function to convert PHP objects to an associative array:

// ---------------------------------------------------------
// ----- object_to_array_recursive --- function (PHP) ------
// ---------------------------------------------------------
// --- arg1: -- $object  =  PHP Object         - required --
// --- arg2: -- $assoc   =  TRUE or FALSE      - optional --
// --- arg3: -- $empty   =  '' (Empty String)  - optional --
// ---------------------------------------------------------
// ----- Return: Array from Object --- (associative) -------
// ---------------------------------------------------------

function object_to_array_recursive($object, $assoc=TRUE, $empty='')
{
    $res_arr = array();

    if (!empty($object)) {

        $arrObj = is_object($object) ? get_object_vars($object) : $object;

        $i=0;
        foreach ($arrObj as $key => $val) {
            $akey = ($assoc !== FALSE) ? $key : $i;
            if (is_array($val) || is_object($val)) {
                $res_arr[$akey] = (empty($val)) ? $empty : object_to_array_recursive($val);
            }
            else {
                $res_arr[$akey] = (empty($val)) ? $empty : (string)$val;
            }
            $i++;
        }
    }
    return $res_arr;
}

// ---------------------------------------------------------
// ---------------------------------------------------------

Usage example:

// ---- Return associative array from object, ... use:
$new_arr1 = object_to_array_recursive($my_object);
// -- or --
// $new_arr1 = object_to_array_recursive($my_object, TRUE);
// -- or --
// $new_arr1 = object_to_array_recursive($my_object, 1);


// ---- Return numeric array from object, ... use:
$new_arr2 = object_to_array_recursive($my_object, FALSE);

Protium

.. or the oneliner: $new_arr1 = (array) $my_object; – Defamation

The oneliner version is shallow, so not equivalent. – Orectic

Answer 15

Custom function to convert stdClass to an array:

function objectToArray($d) {
    if (is_object($d)) {
        // Gets the properties of the given object
        // with get_object_vars function
        $d = get_object_vars($d);
    }

    if (is_array($d)) {
        /*
        * Return array converted to object
        * Using __FUNCTION__ (Magic constant)
        * for recursive call
        */
        return array_map(__FUNCTION__, $d);
    } else {
        // Return array
        return $d;
    }
}

Another custom function to convert Array to stdClass:

function arrayToObject($d) {
    if (is_array($d)) {
        /*
        * Return array converted to object
        * Using __FUNCTION__ (Magic constant)
        * for recursive call
        */
        return (object) array_map(__FUNCTION__, $d);
    } else {
        // Return object
        return $d;
    }
}

Usage Example:

// Create new stdClass Object
$init = new stdClass;

// Add some test data
$init->foo = "Test data";
$init->bar = new stdClass;
$init->bar->baaz = "Testing";
$init->bar->fooz = new stdClass;
$init->bar->fooz->baz = "Testing again";
$init->foox = "Just test";

// Convert array to object and then object back to array
$array = objectToArray($init);
$object = arrayToObject($array);

// Print objects and array
print_r($init);
echo "\n";
print_r($array);
echo "\n";
print_r($object);

Audriaaudrie

Answer 16

First of all, if you need an array from an object you probably should constitute the data as an array first. Think about it.

Don't use a foreach statement or JSON transformations. If you're planning this, again you're working with a data structure, not with an object.

If you really need it use an object-oriented approach to have a clean and maintainable code. For example:

Object as array

class PersonArray implements \ArrayAccess, \IteratorAggregate
{
    public function __construct(Person $person) {
        $this->person = $person;
    }
    // ...
 }

If you need all properties, use a transfer object:

class PersonTransferObject
{
    private $person;

    public function __construct(Person $person) {
        $this->person = $person;
    }

    public function toArray() {
        return [
            // 'name' => $this->person->getName();
        ];
    }

 }

Erythrite

So I would manually assign the wanted properties to array values? Yes that is possible, but I hoped I could avoid that by implementing a _toArray() method in my object, which accomplishes that without manually adding each property. – Kathernkatheryn

Answer 17

This answer is only the union of the different answers of this post, but it's the solution to convert a PHP object with public or private properties with simple values or arrays to an associative array...

function object_to_array($obj)
{
    if (is_object($obj))
        $obj = (array)$this->dismount($obj);
    if (is_array($obj)) {
        $new = array();
        foreach ($obj as $key => $val) {
            $new[$key] = $this->object_to_array($val);
        }
    }
    else
        $new = $obj;
    return $new;
}

function dismount($object)
{
    $reflectionClass = new \ReflectionClass(get_class($object));
    $array = array();
    foreach ($reflectionClass->getProperties() as $property) {
        $property->setAccessible(true);
        $array[$property->getName()] = $property->getValue($object);
        $property->setAccessible(false);
    }
    return $array;
}

Lacedaemonian

Answer 18

Short solution of @SpYk3HH

function objectToArray($o)
{
    $a = array();
    foreach ($o as $k => $v)
        $a[$k] = (is_array($v) || is_object($v)) ? objectToArray($v): $v;

    return $a;
}

Accelerometer

Answer 19

You might want to do this when you obtain data as objects from databases:

// Suppose 'result' is the end product from some query $query

$result = $mysqli->query($query);
$result = db_result_to_array($result);

function db_result_to_array($result)
{
    $res_array = array();

    for ($count=0; $row = $result->fetch_assoc(); $count++)
        $res_array[$count] = $row;

    return $res_array;
}

Astrahan

There is an accepted answer with 41 upvotes, not 1 or 10, 41. What does your answer adds to it? – Meridethmeridian

and the counter is a needless inclusion – Nikitanikki

Answer 20

Also you can use The Symfony Serializer Component

use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;

$serializer = new Serializer([new ObjectNormalizer()], [new JsonEncoder()]);
$array = json_decode($serializer->serialize($object, 'json'), true);

Dibrin

Answer 21

I use this (needed recursive solution with proper keys):

    /**
     * This method returns the array corresponding to an object, including non public members.
     *
     * If the deep flag is true, is will operate recursively, otherwise (if false) just at the first level.
     *
     * @param object $obj
     * @param bool $deep = true
     * @return array
     * @throws \Exception
     */
    public static function objectToArray(object $obj, bool $deep = true)
    {
        $reflectionClass = new \ReflectionClass(get_class($obj));
        $array = [];
        foreach ($reflectionClass->getProperties() as $property) {
            $property->setAccessible(true);
            $val = $property->getValue($obj);
            if (true === $deep && is_object($val)) {
                $val = self::objectToArray($val);
            }
            $array[$property->getName()] = $val;
            $property->setAccessible(false);
        }
        return $array;
    }

Example of usage, the following code:

class AA{
    public $bb = null;
    protected $one = 11;

}

class BB{
    protected $two = 22;
}


$a = new AA();
$b = new BB();
$a->bb = $b;

var_dump($a)

Will print this:

array(2) {
  ["bb"] => array(1) {
    ["two"] => int(22)
  }
  ["one"] => int(11)
}

Rafter

How can we upgrade your function to support objects with array of objects? – Psi

Its an old one - yet the reasonable answer, just pointing out that passing the deep param to the recursive function call is required if we want really to stop recursion. – Carminecarmita

I just tested it and it worked fine. No \u0000 appears with property names and values – Anchor

Answer 22

Converting and removing annoying stars:

$array = (array) $object;
foreach($array as $key => $val)
{
    $new_array[str_replace('*_', '', $key)] = $val;
}

Probably, it will be cheaper than using reflections.

Candicandia

Answer 23

Some impovements to the "well-knwon" code

/*** mixed Obj2Array(mixed Obj)***************************************/ 
static public function Obj2Array($_Obj) {
    if (is_object($_Obj))
        $_Obj = get_object_vars($_Obj);
    return(is_array($_Obj) ? array_map(__METHOD__, $_Obj) : $_Obj);   
} // BW_Conv::Obj2Array

Notice that if the function is member of a class (like above) you must change __FUNCTION__ to __METHOD__

Conundrum

Answer 24

For your case it was right/beautiful if you would use the "decorator" or "date model transformation" patterns. For example:

Your model

class Car {
    /** @var int */
    private $color;

    /** @var string */
    private $model;

    /** @var string */
    private $type;

    /**
     * @return int
     */
    public function getColor(): int
    {
        return $this->color;
    }

    /**
     * @param int $color
     * @return Car
     */
    public function setColor(int $color): Car
    {
        $this->color = $color;
        return $this;
    }

    /**
     * @return string
     */
    public function getModel(): string
    {
        return $this->model;
    }

    /**
     * @param string $model
     * @return Car
     */
    public function setModel(string $model): Car
    {
        $this->model = $model;

        return $this;
    }

    /**
     * @return string
     */
    public function getType(): string
    {
        return $this->type;
    }

    /**
     * @param string $type
     * @return Car
     */
    public function setType(string $type): Car
    {
        $this->type = $type;

        return $this;
    }
}

Decorator

class CarArrayDecorator
{
    /** @var Car */
    private $car;

    /**
     * CarArrayDecorator constructor.
     * @param Car $car
     */
    public function __construct(Car $car)
    {
        $this->car = $car;
    }

    /**
     * @return array
     */
    public function getArray(): array
    {
        return [
            'color' => $this->car->getColor(),
            'type' => $this->car->getType(),
            'model' => $this->car->getModel(),
        ];
    }
}

Usage

$car = new Car();
$car->setType('type#');
$car->setModel('model#1');
$car->setColor(255);

$carDecorator = new CarArrayDecorator($car);
$carResponseData = $carDecorator->getArray();

So it will be more beautiful and more correct code.

Jedlicka

Answer 25

Since a lot of people find this question because of having trouble with dynamically access attributes of an object, I will just point out that you can do this in PHP: $valueRow->{"valueName"}

In context (removed HTML output for readability):

$valueRows = json_decode("{...}"); // Rows of unordered values decoded from a JSON object

foreach ($valueRows as $valueRow) {

    foreach ($references as $reference) {

        if (isset($valueRow->{$reference->valueName})) {
            $tableHtml .= $valueRow->{$reference->valueName};
        }
        else {
            $tableHtml .= " ";
        }
    }
}

Scotticism

Answer 26

There's my proposal, if you have objects in objects with even private members:

public function dismount($object) {
    $reflectionClass = new \ReflectionClass(get_class($object));
    $array = array();
    foreach ($reflectionClass->getProperties() as $property) {
        $property->setAccessible(true);
        if (is_object($property->getValue($object))) {
            $array[$property->getName()] = $this->dismount($property->getValue($object));
        } else {
            $array[$property->getName()] = $property->getValue($object);
        }
        $property->setAccessible(false);
    }
    return $array;
}

Kooima

Answer 27

I think it is a nice idea to use traits to store object-to-array converting logic. A simple example:

trait ArrayAwareTrait
{
    /**
     * Return list of Entity's parameters
     * @return array
     */
    public function toArray()
    {
        $props = array_flip($this->getPropertiesList());
        return array_map(
            function ($item) {
                if ($item instanceof \DateTime) {
                    return $item->format(DATE_ATOM);
                }
                return $item;
            },
            array_filter(get_object_vars($this), function ($key) use ($props) {
                return array_key_exists($key, $props);
            }, ARRAY_FILTER_USE_KEY)
        );
    }


    /**
     * @return array
     */
    protected function getPropertiesList()
    {
        if (method_exists($this, '__sleep')) {
            return $this->__sleep();
        }
        if (defined('static::PROPERTIES')) {
            return static::PROPERTIES;
        }
        return [];
    }
}

class OrderResponse
{
    use ArrayAwareTrait;

    const PROP_ORDER_ID = 'orderId';
    const PROP_TITLE = 'title';
    const PROP_QUANTITY = 'quantity';
    const PROP_BUYER_USERNAME = 'buyerUsername';
    const PROP_COST_VALUE = 'costValue';
    const PROP_ADDRESS = 'address';

    private $orderId;
    private $title;
    private $quantity;
    private $buyerUsername;
    private $costValue;
    private $address;

    /**
     * @param $orderId
     * @param $title
     * @param $quantity
     * @param $buyerUsername
     * @param $costValue
     * @param $address
     */
    public function __construct(
        $orderId,
        $title,
        $quantity,
        $buyerUsername,
        $costValue,
        $address
    ) {
        $this->orderId = $orderId;
        $this->title = $title;
        $this->quantity = $quantity;
        $this->buyerUsername = $buyerUsername;
        $this->costValue = $costValue;
        $this->address = $address;
    }

    /**
     * @inheritDoc
     */
    public function __sleep()
    {
        return [
            static::PROP_ORDER_ID,
            static::PROP_TITLE,
            static::PROP_QUANTITY,
            static::PROP_BUYER_USERNAME,
            static::PROP_COST_VALUE,
            static::PROP_ADDRESS,
        ];
    }

    /**
     * @return mixed
     */
    public function getOrderId()
    {
        return $this->orderId;
    }

    /**
     * @return mixed
     */
    public function getTitle()
    {
        return $this->title;
    }

    /**
     * @return mixed
     */
    public function getQuantity()
    {
        return $this->quantity;
    }

    /**
     * @return mixed
     */
    public function getBuyerUsername()
    {
        return $this->buyerUsername;
    }

    /**
     * @return mixed
     */
    public function getCostValue()
    {
        return $this->costValue;
    }

    /**
     * @return string
     */
    public function getAddress()
    {
        return $this->address;
    }
}

$orderResponse = new OrderResponse(...);
var_dump($orderResponse->toArray());

Leniency

Answer 28

$Menu = new Admin_Model_DbTable_Menu(); 
$row = $Menu->fetchRow($Menu->select()->where('id = ?', $id));
$Addmenu = new Admin_Form_Addmenu(); 
$Addmenu->populate($row->toArray());

Gens

I'm assuming which this answer is for a Doctrine (or similar) record. – Eight

Answer 29

Here I've made an objectToArray() method, which also works with recursive objects, like when $objectA contains $objectB which points again to $objectA.

Additionally I've restricted the output to public properties using ReflectionClass. Get rid of it, if you don't need it.

    /**
     * Converts given object to array, recursively.
     * Just outputs public properties.
     *
     * @param object|array $object
     * @return array|string
     */
    protected function objectToArray($object) {
        if (in_array($object, $this->usedObjects, TRUE)) {
            return '**recursive**';
        }
        if (is_array($object) || is_object($object)) {
            if (is_object($object)) {
                $this->usedObjects[] = $object;
            }
            $result = array();
            $reflectorClass = new \ReflectionClass(get_class($this));
            foreach ($object as $key => $value) {
                if ($reflectorClass->hasProperty($key) && $reflectorClass->getProperty($key)->isPublic()) {
                    $result[$key] = $this->objectToArray($value);
                }
            }
            return $result;
        }
        return $object;
    }

To identify already used objects, I am using a protected property in this (abstract) class, named $this->usedObjects. If a recursive nested object is found, it will be replaced by the string **recursive**. Otherwise it would fail in because of infinite loop.

Suazo

$usedObjects is not initialised at the start, so calling this multiple times will give incorrect results in later calls. Also, you don't free it up at the end, so your objects will never be removed from memory. – Convey

Answer 30

Not a new solution but includes toArray method conversion when available

function objectToArray($r)
{
  if (is_object($r)) {
    if (method_exists($r, 'toArray')) {
      return $r->toArray(); // returns result directly
    } else {
      $r = get_object_vars($r);
    }
  }

  if (is_array($r)) {
    $r = array_map(__FUNCTION__, $r); // recursive function call
  }

  return $r;
}

Century

Answer 31

function object_to_array(array|object $data) : array {
  $result = (array) $data;  
  foreach ($result as $key => $value) {
    if (is_object($value))
      $value = (array) $value;
    if (is_array($value))
      $result[$key] = object_to_array($value);
  }
  return $result;
}

Example:

class x {
  var $a = "hello";
}
class y {
   var $b = 1;
   var $c = 2;
   var $d = "abc";
   var $e = null;
   public function __construct() {
       $this->e = new x();
   }
}

var_dump(object_to_array(new y()));

Output:

array(4) {
  ["b"]=> int(1)
  ["c"]=> int(2)
  ["d"]=> string(3) "abc"
  ["e"]=> array(1) {
    ["a"]=> string(5) "hello"
  }
}

Nonu

\u0000 is appearing with all property names and their values. Can we avoid it? Also name of the class appears with all properties – Anchor

@Syed there is no name of a class on the result, there is only the name "a" from the property "a" from class "y". – Nonu

First, this code is incorrect as it fails to convert some nested objects. Second, it's just incorrect implementation of existing answer. Please read other answers before posting your own. – Illfavored

first, nested objects are not failed. second, if you meen the problem with private/protected properties than you are right. But then you must make an discussion: Is an private property realy "exportable"? – Nonu

Answer 32

I tested it in Laravel Collections, this is working well.

function objectToArray($data)
{
    if (is_array($data) || is_object($data))
    {
        $result = [];
        foreach ($data as $key => $value)
        {
            $result[$key] = (is_array($data) || is_object($data)) ? objectToArray($value) : $value;
        }
        return $result;
    }
    return $data;
}

A1