Question Convertir un objet PHP en tableau associatif


J'intègre une API sur mon site Web qui fonctionne avec des données stockées dans des objets pendant que mon code est écrit en utilisant des tableaux.

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


571
2017-12-03 12:34


origine


Réponses:


Juste le classer

$array =  (array) $yourObject;

De http://www.php.net/manual/en/language.types.array.php

Si un objet est converti en 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 des entiers ne sont pas accessibles; 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 valeurs préfixées 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(
  )),
)

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

Voir aussi cet article de blog approfondi:


1095
2017-12-03 12:40



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

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

257
2018-04-19 18:56



Du premier coup de Google pour "objet php à 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.


61
2018-04-15 19:48



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

$array =  (array) $object;

Si elles sont privées ou protégées, elles auront des noms de clé bizarres 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;
}

49
2018-02-05 11:09



Toutes les autres réponses publié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
2018-01-09 02:41



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
2017-09-20 15:33



Voici du 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
2017-12-11 14:21



Qu'en est-il de get_object_vars($obj)? Cela 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
2018-06-29 12:53



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

$name_of_array =  (array) $name_of_object;

5
2018-02-03 14:38



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
2018-02-25 19:24



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
2018-02-27 09:51