Convertir un objet PHP en tableau associatif

J'intègre une API à mon site web qui fonctionne avec des données stockées dans des objets pendant que mon code est écrit à l'aide de tableaux.

Je voudrais une fonction rapide et sale pour convertir un objet en un tableau.

592
demandé sur random 2010-12-03 15:34:16

27 réponses

Juste typecast

$array =  (array) $yourObject;

À Partir de http://www.php.net/manual/en/language.types.array.php

Si un objet est converti en un tableau, le résultat est un tableau dont les éléments sont les propriétés de l'objet. Les clés sont les noms des variables membres, avec quelques exceptions notables: les propriétés entières sont inaccessibles; les variables privées ont le nom de la classe ajouté au nom de la variable; les variables protégées ont un ' * ' Ajouté au nom de la variable. Ces préfixés les valeurs ont des octets nuls de chaque côté.

Exemple: Objet Simple

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

var_dump( (array) $object );

Sortie:

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

Exemple: Objet Complexe

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

sortie (avec \0s édité pour plus de clarté):

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

Sortie avec var_export au lieu de var_dump:

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

La Typecasting de cette façon ne fera pas de moulage en profondeur du graphe d'objet et vous devez appliquer les octets null (comme expliqué dans la citation manuelle) pour accéder à tout attributs non publics. Cela fonctionne donc mieux lors de la conversion D'objets StdClass ou d'objets avec uniquement des propriétés publiques. Rapide et sale (ce que vous avez demandé), c'est bien.

Voir Aussi ce billet de blog en profondeur:

1120
répondu Gordon 2015-08-18 16:02:29

Vous pouvez rapidement convertir des objets profondément imbriqués en tableaux associatifs en vous appuyant sur le comportement des fonctions JSON encode / decode:

$array = json_decode(json_encode($nested_object), true);
264
répondu Jeff Standen 2013-04-19 18:56:23

Du premier coup de Google pour "php object to Assoc array " nous avons ceci:

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

Source à codesnippets.joyent.com.

62
répondu István Ujj-Mészáros 2015-01-19 12:06:17

Si les propriétés de votre objet sont publiques, vous pouvez faire:

$array =  (array) $object;

S'ils sont privés ou protégés, ils auront des noms de clés étranges sur le tableau. Donc, dans ce cas, vous aurez besoin de la fonction suivante:

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;
}
50
répondu ramonztro 2013-10-23 10:12:37

Toutes les autres réponses affichées ici ne fonctionnent qu'avec des attributs publics. Voici une solution qui fonctionne avec JavaBean -comme des objets utilisant la réflexion et les 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;
}
9
répondu Francois Bourgeois 2013-02-15 12:22:34
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());

Sortie

array(2) {
    ["b"]=>
    string(3) "two"
    ["Testc"]=>
    int(1)
}
array(1) {
    ["b"]=>
    string(3) "two"
}
9
répondu Isius 2014-01-09 02:41:23

Voici un 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;
}
7
répondu Khalid 2011-09-20 16:58:37

Et get_object_vars($obj)? Semble utile si vous voulez seulement accéder aux propriétés publiques d'un objet. http://www.php.net/function.get-object-vars

6
répondu Joe 2013-12-11 14:21:02

Pour convertir un objet en tableau, il suffit de le lancer explicitement

$name_of_array =  (array) $name_of_object;
5
répondu Shrish Shrivastava 2015-06-29 13:14:51

Type cast votre objet dans un tableau.

$arr =  (array) $Obj;

Il va résoudre votre problème.

5
répondu Adeel 2017-11-22 07:08:49

Salut,

Voici ma fonction PHP récursive pour convertir des objets PHP en un tableau associatif

// --------------------------------------------------------- 
// ----- object_to_array_recusive --- 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_recusive ( $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_recusive($val); 
            } 
            else { 
                $res_arr[$akey] = (empty($val)) ? $empty : (string)$val; 
            } 

        $i++; 
        }

    } 

    return $res_arr;
}


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

Exemple d'Utilisation:

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


// ---- return numeric array from object, ... use: 
$new_arr2 = object_to_array_recusive($my_object,FALSE); 
4
répondu rabatto 2014-02-20 23:03:07

Fonction personnalisée pour convertir stdClass en tableau:

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;
    }
}

Une autre fonction personnalisée pour convertir le tableau en 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;
    }
}

Exemple D'Utilisation:

    // 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);
4
répondu MacLover 2014-02-25 19:32:55

Vous pouvez également créer une fonction en PHP pour convertir un tableau d'objets.

function object_to_array($object) {
    return (array) $object;
}
4
répondu Rakhi Prajapati 2017-02-27 09:51:18

Vous pouvez le faire lorsque vous obtenez des données en tant qu'objets à partir de bases de données -- >

// 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;
}
3
répondu metaldog 2012-07-17 22:43:38
function readObject($object) {
    $name = get_class ($object);
    $name = str_replace('\\', "\\\\", $name); \\ Comment this line, if you dont 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;
}

Renvoie un tableau sans caractères spéciaux et sans noms de classe

3
répondu ovnia 2014-06-12 19:24:00

Tout d'abord, si vous avez besoin d'un array from object, vous devriez probablement constituer les données en tant que tableau en premier. Pensez à ce sujet.

N'utilisez pas l'instruction foreach ou les transformations JSON. Si vous planifiez cela, encore une fois, vous travaillez avec une structure de données, pas avec un objet.

Si vous en avez vraiment besoin, utilisez une approche orientée objet pour avoir un code propre et maintable. Par exemple:

Objet en tant que Tableau

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

Si vous avez besoin de toutes les propriétés, utilisez transfer object

class PersonTransferObject
{
    private $person;

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

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

 }
3
répondu John Smith 2016-02-27 09:38:46

Cette fonction peut convertir propriété d'objet en tableau associatif

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;
  }

Utiliser >= php5

3
répondu Fiacre AYEDOUN 2016-09-01 13:43:55

Conversion et suppression des étoiles gênantes:

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

Probablement, ce sera moins cher que d'utiliser des réflexions.

2
répondu Fedir RYKHTIK 2014-02-03 08:54:15

Quelques impovements au code "well-knwon"

/*** 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

Notez que si la fonction membre d'une classe (comme ci-dessus), vous devez modifier __FUNCTION__ à __METHOD__

1
répondu Gilbert BENABOU 2015-07-24 13:23:35

Vous pouvez également utiliser le composant Symfony Serializer

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);
1
répondu Andrey Nilov 2017-01-26 11:55:04
$Menu = new Admin_Model_DbTable_Menu(); 
$row = $Menu->fetchRow($Menu->select()->where('id = ?', $id));
$Addmenu = new Admin_Form_Addmenu(); 
$Addmenu->populate($row->toArray());
0
répondu Saurabh Chandra Patel 2014-05-07 10:11:14

Ici, j'ai créé une méthodeobjectToArray () , qui fonctionne également avec des objets récursifs, comme lorsque $objectA contient $objectB qui pointe à nouveau vers $objectA.

De plus, j'ai limité la sortie aux propriétés publiques en utilisant ReflectionClass. Se débarrasser d'elle, si vous n'en avez pas besoin.

    /**
     * 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;
    }

Pour identifier les objets déjà utilisés, j'utilise une propriété protégée dans cette classe (abstraite), nommée $this->usedObjects. Si un objet imbriqué récursif est trouvé, il sera remplacé par la chaîne **recursive**. Sinon, il échouerait à cause de la boucle infinie.

0
répondu Armin 2015-05-15 00:31:21

Cette réponse n'est que l'union des différentes réponses de ce post, mais c'est la solution pour convertir un objet PHP avec des propriétés publiques ou privées avec des valeurs simples ou des tableaux dans un tableau associatif ...

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;
}
0
répondu Daniel Guerrero 2016-06-08 15:48:29

Solution courte de @SpYk3HH

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

    return $a;
}
0
répondu Bsienn 2017-01-25 12:17:40

En utilisant la typecasting, vous pouvez résoudre votre problème. Ajoutez simplement les lignes suivantes à votre objet de retour:

$arrObj = array(yourReturnedObject);

Vous pouvez également ajouter une nouvelle paire de clés et de valeurs en utilisant:

$arrObj['key'] = value;
0
répondu Naveen Gupta 2017-04-20 09:54:07

Comme beaucoup de gens trouvent ce thread à cause d'avoir des problèmes avec l'accès dynamique aux attributs d'un objet, je vais simplement souligner que vous pouvez le faire en php: $valueRow->{"valueName"}

Dans le contexte (sortie HTML supprimée pour la lisibilité):

$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 .= " ";
        }

    }

}
0
répondu radiatedDogsInFukushima 2017-11-22 05:56:36

Il y a ma proposition, si vous avez des objets dans des objets avec même des membres privés:

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;
}
0
répondu Karol Gasienica 2018-03-22 12:52:59