উত্তর:
শুধু এটি টাইপকাস্ট করুন
$array = (array) $yourObject;অ্যারে থেকে :
যদি কোনও বস্তু অ্যারেতে রূপান্তরিত হয় তবে ফলাফলটি একটি অ্যারে হয় যার উপাদানগুলি বস্তুর বৈশিষ্ট্য। কীগুলি কয়েকটি উল্লেখযোগ্য ব্যতিক্রম সহ সদস্যের পরিবর্তনশীল নাম: পূর্ণসংখ্যা বৈশিষ্ট্য অ্যাক্সেসযোগ্য; প্রাইভেট ভেরিয়েবলের বর্গের নামটি ভেরিয়েবলের নামের পরিবর্তে থাকে; সুরক্ষিত ভেরিয়েবলের ভেরিয়েবল নামের একটি '*' থাকে। এই চাপ দেওয়া মানগুলির দুপাশে নাল বাইট রয়েছে।
উদাহরণ: সরল অবজেক্ট
$object = new StdClass;
$object->foo = 1;
$object->bar = 2;
var_dump( (array) $object );
আউটপুট:
array(2) {
'foo' => int(1)
'bar' => int(2)
}
উদাহরণ: জটিল অবজেক্ট
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 );
আউটপুট (স্পষ্টতার জন্য সম্পাদিত \ 0s সহ):
array(3) {
'\0Foo\0foo' => int(1)
'\0*\0bar' => int(2)
'baz' => class stdClass#2 (0) {}
}
এর var_exportপরিবর্তে আউটপুট var_dump:
array (
'' . "\0" . 'Foo' . "\0" . 'foo' => 1,
'' . "\0" . '*' . "\0" . 'bar' => 2,
'baz' =>
stdClass::__set_state(array(
)),
)
এভাবে টাইপকাস্টিং করা অবজেক্ট গ্রাফের গভীর ingালাই করবে না এবং আপনাকে কোনও নন-পাবলিক বৈশিষ্ট্য অ্যাক্সেস করতে নাল বাইটগুলি (ম্যানুয়াল উদ্ধৃতিতে বর্ণিত) প্রয়োগ করতে হবে। সুতরাং শুধুমাত্র সর্বজনীন বৈশিষ্ট্যযুক্ত স্টিডক্লাস বস্তু বা বস্তু কাস্ট করার সময় এটি সেরা কাজ করে। দ্রুত এবং নোংরা (আপনি যা চেয়েছিলেন) এটি ঠিক আছে।
এই গভীরতর ব্লগ পোস্টটি দেখুন:
[1 => "one"]হয়ে["1" => "one"]
(array)এবং (object)নির্ভরযোগ্যভাবে কাজ করে এবং পিএইচপি 4.3 যেহেতু সব সংস্করণের জুড়ে একই। 3v4l.org/X6lhm দেখুন । যদি আপনি একটি সিনট্যাক্স ত্রুটি পান তবে আপনি কিছু ভুল করেছেন।
আপনি JSON এনকোড / ডিকোড ফাংশনগুলির আচরণের উপর নির্ভর করে দ্রুত গভীরভাবে বাসাযুক্ত জিনিসগুলিকে সহযোগী অ্যারে রূপান্তর করতে পারেন:
$array = json_decode(json_encode($nested_object), true);" পিএইচপি অবজেক্ট টু এসোসিয়ে অ্যারে " এর জন্য প্রথম গুগল হিট থেকে আমাদের এটি রয়েছে :
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;
}
উত্সটি কোডনিপেটস.জয়য়েন্ট.কম এ রয়েছে ।
function objectToArray($o) { $a = array(); foreach ($o as $k => $v) $a[$k] = (is_array($v) || is_object($v)) ? objectToArray($v): $v; return $a; }এটি কেবল এমন কোনও কিছু সেট করে যা যা কোনও অবজেক্ট বা অ্যারে নয় এবং প্রয়োজন ব্যতীত পদ্ধতিতে পুনরাবৃত্তি না করে অবিরত থাকবে।
যদি আপনার অবজেক্টের বৈশিষ্ট্যগুলি সর্বজনীন হয় তবে আপনি এটি করতে পারেন:
$array = (array) $object;যদি তারা ব্যক্তিগত বা সুরক্ষিত থাকে তবে অ্যারেতে তাদের অদ্ভুত কী নাম থাকবে। সুতরাং, এই ক্ষেত্রে আপনার নিম্নলিখিত ফাংশনটির প্রয়োজন হবে:
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;
}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());আউটপুট
array(2) {
["b"]=>
string(3) "two"
["Testc"]=>
int(1)
}
array(1) {
["b"]=>
string(3) "two"
}এখানে কিছু কোড রয়েছে:
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;
}এখানে পোস্ট করা অন্যান্য সমস্ত উত্তর কেবল জনসাধারণের গুণাবলী নিয়ে কাজ করছে। প্রতিবিম্ব এবং গেটার্স ব্যবহার করে জাভাবিনের মতো জিনিসগুলির সাথে কাজ করে এমন একটি সমাধান এখানে দেওয়া হয়েছে :
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;
}publicবৈশিষ্ট্য ব্যতীত আপনার অন্য কিছু কেন দরকার ?
কি হবে get_object_vars($obj)? আপনি যদি কোনও বস্তুর সর্বজনীন বৈশিষ্ট্যগুলি অ্যাক্সেস করতে চান তবে এটি দরকারী বলে মনে হচ্ছে।
Get_object_vars দেখুন ।
প্রথমত, আপনার যদি কোনও অবজেক্ট থেকে অ্যারের প্রয়োজন হয় তবে আপনার সম্ভবত ডেটাটি একটি অ্যারে হিসাবে গঠন করা উচিত। চিন্তা করুন.
কোনও foreachবিবৃতি বা জেএসএন রূপান্তর ব্যবহার করবেন না । আপনি যদি এটি পরিকল্পনা করে থাকেন, আবার আপনি কোনও অবজেক্টের সাথে নয়, একটি ডেটা স্ট্রাকচারের সাথে কাজ করছেন।
আপনার যদি সত্যিই প্রয়োজন হয় তবে এটি পরিষ্কার এবং রক্ষণাবেক্ষণযোগ্য কোড রাখতে কোনও অবজেক্ট-ভিত্তিক পদ্ধতির ব্যবহার করুন। উদাহরণ স্বরূপ:
অ্যারে হিসাবে অবজেক্ট
class PersonArray implements \ArrayAccess, \IteratorAggregate
{
public function __construct(Person $person) {
$this->person = $person;
}
// ...
}আপনার যদি সমস্ত সম্পত্তি প্রয়োজন হয়, একটি স্থানান্তর বস্তু ব্যবহার করুন:
class PersonTransferObject
{
private $person;
public function __construct(Person $person) {
$this->person = $person;
}
public function toArray() {
return [
// 'name' => $this->person->getName();
];
}
}ফলাফল পেতে আপনি সহজেই এই ফাংশনটি ব্যবহার করতে পারেন:
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;
}পিএইচপি 5 বা তারপরে ব্যবহার করুন ।
পিএইচপি অবজেক্টগুলিকে কোনও এসোসিয়েটিভ অ্যারে রূপান্তর করতে এখানে আমার পুনরাবৃত্ত পিএইচপি ফাংশন রয়েছে:
// ---------------------------------------------------------
// ----- 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;
}
// ---------------------------------------------------------
// ---------------------------------------------------------ব্যবহারের উদাহরণ:
// ---- 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);$new_arr1 = (array) $my_object;
কোনও বস্তুকে অ্যারেতে রূপান্তর করতে কেবল এটিকে স্পষ্টভাবে কাস্ট করুন:
$name_of_array = (array) $name_of_object;আপনি কোনও বস্তুর অ্যারে রূপান্তর করতে পিএইচপি তেও একটি ফাংশন তৈরি করতে পারেন:
function object_to_array($object) {
return (array) $object;
}আপনি যখন ডাটাবেসগুলি থেকে অবজেক্ট হিসাবে ডেটা পাবেন তখন আপনি এটি করতে চাইবেন:
// 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;
}StdClass কে একটি অ্যারেতে রূপান্তর করতে কাস্টম ফাংশন:
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;
}
}অ্যারেটিকে 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;
}
}ব্যবহারের উদাহরণ:
// 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);ব্যবহার করুন:
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;
}এটি বিশেষ অক্ষর এবং শ্রেণীর নাম ছাড়াই একটি অ্যারে প্রদান করে।
এই উত্তরটি এই পোস্টের বিভিন্ন উত্তরগুলির একমাত্র ইউনিয়ন, তবে পিএইচপি অবজেক্টকে সরল মান বা অ্যারে সহ সরকারী বা বেসরকারী সম্পত্তিগুলির সাথে একটি সহযোগী অ্যারে রূপান্তর করার সমাধান ...
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;
}"ভাল-নন" কোডটিতে কিছু ইমপ্রোভেশন
/*** 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লক্ষ্য করুন যে ফাংশনটি কোনও শ্রেণীর সদস্য হলে (উপরের মতো) আপনাকে অবশ্যই পরিবর্তন __FUNCTION__করতে হবে__METHOD__
এছাড়াও আপনি সিমফনি সিরিয়ালাইজার উপাদান ব্যবহার করতে পারেন
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);আপনার ক্ষেত্রে এটি সঠিক / সুন্দর ছিল যদি আপনি "সাজসজ্জার" বা "তারিখের মডেল রূপান্তর" নিদর্শন ব্যবহার করেন। উদাহরণ স্বরূপ:
আপনার মডেল
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;
}
}প্রসাধক
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(),
];
}
}ব্যবহার
$car = new Car();
$car->setType('type#');
$car->setModel('model#1');
$car->setColor(255);
$carDecorator = new CarArrayDecorator($car);
$carResponseData = $carDecorator->getArray();সুতরাং এটি আরও সুন্দর এবং আরও সঠিক কোড হবে।
বিরক্তিকর তারাগুলি রূপান্তর করা এবং অপসারণ:
$array = (array) $object;
foreach($array as $key => $val)
{
$new_array[str_replace('*_', '', $key)] = $val;
}সম্ভবত, এটি প্রতিবিম্ব ব্যবহার করার চেয়ে সস্তা হবে।
যেহেতু অনেক লোক এই বিষয়টিকে কোনও বস্তুর গতিশীল অ্যাক্সেস বৈশিষ্ট্যগুলির সাথে সমস্যা হওয়ায় এই প্রশ্নটি আবিষ্কার করে, আমি কেবল উল্লেখ করব যে আপনি পিএইচপি-তে এটি করতে পারেন: $valueRow->{"valueName"}
প্রসঙ্গে (পাঠযোগ্যতার জন্য সরানো এইচটিএমএল আউটপুট):
$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 .= " ";
}
}
}টাইপকাস্টিং ব্যবহার করে আপনি আপনার সমস্যার সমাধান করতে পারেন। আপনার রিটার্ন অবজেক্টে কেবল নিম্নলিখিত লাইনগুলি যুক্ত করুন:
$arrObj = array(yourReturnedObject);আপনি এটি ব্যবহার করে এটিতে একটি নতুন কী এবং মান জোড়া যুক্ত করতে পারেন:
$arrObj['key'] = value;আমি মনে করি অবজেক্ট-টু-অ্যারে রূপান্তরকারী যুক্তি সঞ্চয় করার জন্য বৈশিষ্ট্যগুলি ব্যবহার করা ভাল ধারণা। একটি সহজ উদাহরণ:
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());$Menu = new Admin_Model_DbTable_Menu();
$row = $Menu->fetchRow($Menu->select()->where('id = ?', $id));
$Addmenu = new Admin_Form_Addmenu();
$Addmenu->populate($row->toArray());এখানে আমি একটি অবজেক্টোআররে () পদ্ধতি তৈরি করেছি , যা পুনরাবৃত্ত বস্তুগুলির সাথেও কাজ করে, যেমন কখন আবার কোন পয়েন্ট $objectAথাকে ।$objectB$objectA
অতিরিক্তভাবে আমি রিফ্লেকশন ক্লাস ব্যবহার করে আউটপুটটিকে সর্বজনীন বৈশিষ্ট্যে সীমাবদ্ধ করে রেখেছি। আপনার যদি এটির প্রয়োজন না হয় তবে এ থেকে মুক্তি পান।
/**
* 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;
}ইতিমধ্যেই ব্যবহার বস্তু চিহ্নিত করার, আমি এই (বিমূর্ত) ক্লাসে কোনো সুরক্ষিত সম্পত্তি, নামে ব্যবহার করছি $this->usedObjects। যদি কোনও পুনরাবৃত্ত নেস্টেড বস্তু পাওয়া যায় তবে এটি স্ট্রিং দ্বারা প্রতিস্থাপিত হবে **recursive**। অন্যথায় এটি অসীম লুপের কারণে ব্যর্থ হবে।
$usedObjectsশুরুতে আরম্ভ করা হয় না, তাই একাধিকবার কল করা পরবর্তী কলগুলিতে ভুল ফলাফল দেয়। এছাড়াও, আপনি এটিকে শেষে মুক্ত করবেন না, সুতরাং আপনার জিনিসগুলি কখনই স্মৃতি থেকে সরানো হবে না।
আমার প্রস্তাবটি আছে, যদি আপনার এমনকি ব্যক্তিগত সদস্যদের সাথে বস্তুগুলিতে জিনিস থাকে:
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;
}আমি এটি ব্যবহার করি (যথাযথ কীগুলির সাথে পুনরাবৃত্তির সমাধান প্রয়োজন):
/**
* 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;
}ব্যবহারের উদাহরণ, নিম্নলিখিত কোড:
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)এটি মুদ্রণ করবে:
array(2) {
["bb"] => array(1) {
["two"] => int(22)
}
["one"] => int(11)
}
ArrayAccessইন্টারফেসটিও বিবেচনা করুন , সম্ভবত এই সমাধানের সাথে একত্রে। php.net/manual/en/class.arrayaccess.php