Pregunta Convierta objeto PHP a matriz asociativa


Estoy integrando una API a mi sitio web que funciona con datos almacenados en objetos mientras mi código está escrito usando matrices.

Me gustaría una función rápida y sucia para convertir un objeto en una matriz.


571
2017-12-03 12:34


origen


Respuestas:


Solo encasillarlo

$array =  (array) $yourObject;

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

Si un objeto se convierte en una matriz, el resultado es una matriz cuyos elementos son las propiedades del objeto. Las claves son los nombres de las variables miembro, con algunas excepciones notables: las propiedades enteras son inaccesibles; las variables privadas tienen el nombre de clase antepuesto al nombre de la variable; las variables protegidas tienen un '*' antepuesto al nombre de la variable. Estos valores antepuestos tienen bytes nulos en cualquier lado.

Ejemplo: Objeto simple

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

var_dump( (array) $object );

Salida:

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

Ejemplo: objeto complejo

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

Salida (con \ 0s editado para mayor claridad):

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

Salida con var_export en lugar de var_dump:

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

La conversión de tipos de esta forma no hará un fundido profundo del gráfico de objetos y deberá aplicar los bytes nulos (como se explica en la cita manual) para acceder a cualquier atributo que no sea público. Por lo tanto, esto funciona mejor cuando se lanzan objetos u objetos StdClass con solo propiedades públicas. Para rápido y sucio (lo que pediste) está bien.

También vea esta publicación en profundidad del blog:


1095
2017-12-03 12:40



Puede convertir rápidamente objetos profundamente anidados en matrices asociativas confiando en el comportamiento de las funciones de codificación / decodificación JSON:

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

257
2018-04-19 18:56



Desde el primer hit de Google para "php object para assoc array"tenemos esto:

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

Fuente en codesnippets.joyent.com.


61
2018-04-15 19:48



Si las propiedades de tus objetos son públicas, puedes hacer lo siguiente:

$array =  (array) $object;

Si son privados o están protegidos, tendrán nombres de teclas extraños en la matriz. Entonces, en este caso necesitarás la siguiente función:

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



Todas las demás respuestas publicadas aquí solo funcionan con atributos públicos. Aquí hay una solución que funciona con javabean-como objetos usando reflexión y 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());

Salida

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

9
2017-09-20 15:33



Aquí hay un código:

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é pasa get_object_vars($obj)? Parece útil si solo quiere acceder a las propiedades públicas de un objeto. http://www.php.net/function.get-object-vars


6
2018-06-29 12:53



Para convertir un objeto en matriz, simplemente expórtelo explícitamente

$name_of_array =  (array) $name_of_object;

5
2018-02-03 14:38



Hola,

Aquí está mi función recursiva de PHP para convertir objetos de PHP a una matriz asociativa

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


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

Ejemplo de uso:

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



Función personalizada para convertir stdClass en matriz:

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

Otra función personalizada para convertir Array 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;
    }
}

Ejemplo de uso:

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