objetos - obtener valor de un objeto php

Convertir objeto PHP a matriz asociativa

Question

Estoy integrando una API a mi sitio web que funciona con datos almacenados en objetos mientras mi código se escribe usando arreglos.

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

Answer 1

¿Qué hay de get_object_vars($obj) ? Parece útil si solo desea acceder a las propiedades públicas de un objeto. http://www.php.net/function.get-object-vars

Answer 2

Algunas mejoras al código "bien conocido"

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

Observe que si la función es miembro de una clase (como la anterior), debe cambiar __FUNCTION__ a __METHOD__

Answer 3

Aquí está mi propuesta, si tiene objetos en objetos con miembros incluso privados:

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

Answer 4

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

Answer 5

Aquí he creado un método objectToArray () , que también funciona con objetos recursivos, como cuando $objectA contiene $objectB que apunta de nuevo a $objectA .

Además, he restringido la salida a propiedades públicas usando ReflectionClass. Deshazte de él, si no lo necesitas.

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

Para identificar objetos ya usados, estoy usando una propiedad protegida en esta clase (abstracta), llamada $this->usedObjects . Si se encuentra un objeto anidado recursivo, será reemplazado por la cadena **recursive** . De lo contrario, fallaría debido a un bucle infinito.

Answer 6

Como mucha gente encuentra este hilo debido a tener problemas con el acceso dinámico de los atributos de un objeto, solo $valueRow->{"valueName"} que puede hacer esto en php: $valueRow->{"valueName"}

En contexto (se eliminó la salida HTML para facilitar la lectura):

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

Answer 7

Convertir y eliminar estrellas molestas:

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

Probablemente, será más barato que usar reflexiones.

Answer 8

Desde el primer hit de Google para " php object to 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 .

Answer 9

En primer lugar, si necesita una matriz de un objeto, probablemente debería constituir primero los datos como matriz. Piénsalo.

No utilice la instrucción foreach o las transformaciones JSON. Si está planeando esto, nuevamente está trabajando con una estructura de datos, no con un objeto.

Si realmente lo necesita, utilice un enfoque orientado a objetos para tener un código limpio y de tabla principal. Por ejemplo:

Objeto como matriz

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

Si necesitas todas las propiedades usa objeto de transferencia.

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

Answer 10

Es posible que desee hacer esto cuando obtenga datos como objetos de bases de datos ->

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

Answer 11

Escriba convertir su objeto a una matriz.

$arr = (array) $Obj;

Solucionará tu problema.

Answer 12

Esta respuesta es solo la unión de las diferentes respuestas de esta publicación, pero es la solución para convertir un objeto PHP con propiedades públicas o privadas con valores simples o matrices en una matriz asociativa ...

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

Answer 13

Función personalizada para convertir stdClass a 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;
}
}

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

Answer 14

Hola,

Aquí está mi función recursiva de PHP para convertir objetos 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);

Answer 15

Mediante el uso del encasillado puede resolver su problema. Simplemente agregue las siguientes líneas a su objeto de retorno:

$arrObj = array(yourReturnedObject);

También puede agregarle un nuevo par de clave y valor usando:

$arrObj[''key''] = value;

Answer 16

Para convertir un objeto en una matriz, simplemente conviértelo explícitamente

$name_of_array = (array) $name_of_object;

Answer 17

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

Answer 18

Sólo enciéndelo

$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 de enteros no son accesibles; Las variables privadas tienen el nombre de la clase ante el nombre de la variable; Las variables protegidas tienen un ''*'' ante el nombre de la variable. Estos valores prefabricados 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 lugar de var_dump :

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

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

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

• http://ocramius.github.io/blog/fast-php-object-to-array-conversion/

Answer 19

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

$array = (array) $object;

Si son privados o están protegidos, tendrán nombres de clave 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;
}

Answer 20

Solución corta 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;
}

Answer 21

También puede crear una función en PHP para convertir la matriz de objetos.

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

Answer 22

También puedes usar el componente 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);

Answer 23

Todas las demás respuestas publicadas aquí solo funcionan con atributos públicos. Aquí hay una solución que funciona con objetos similares a javabean usando reflexiones y captadores:

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

Answer 24

esta función puede convertir la propiedad del objeto a array asociatif

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

usar> = php5

Answer 25

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

Answer 26

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

Answer 27

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

devuelve matriz sin caracteres especiales y nombres de clase