Как я могу преобразовать массив, подобный этому, в объект?
[128] => Array
(
[status] => Figure A.
Facebook horizontal scrollbars showing up on a 1024x768 screen resolution.
)
[129] => Array
(
[status] => The other day at work, I had some spare time
)
)
Это работало для меня
function array_to_obj($array, &$obj)
{
foreach ($array as $key => $value)
{
if (is_array($value))
{
$obj->$key = new stdClass();
array_to_obj($value, $obj->$key);
}
else
{
$obj->$key = $value;
}
}
return $obj;
}
function arrayToObject($array)
{
$object= new stdClass();
return array_to_obj($array,$object);
}
использование
$myobject = arrayToObject($array);
print_r($myobject);
возвращает:
[127] => stdClass Object
(
[status] => Have you ever created a really great looking website design
)
[128] => stdClass Object
(
[status] => Figure A.
Facebook horizontal scrollbars showing up on a 1024x768 screen resolution.
)
[129] => stdClass Object
(
[status] => The other day at work, I had some spare time
)
, как обычно, вы можете зацикливать его так:
foreach($myobject as $obj)
{
echo $obj->status;
}
В простейшем случае, вероятно, достаточно "отличить" массив как объект:
$object = (object) $array;
Другой вариант - создать экземпляр стандартного класса в качестве переменной и выполнить цикл через массив при повторном присвоении значений:
$object = new stdClass();
foreach ($array as $key => $value)
{
$object->$key = $value;
}
Как отметил Edson Medina, действительно чистое решение - использовать встроенные функции json_:
$object = json_decode(json_encode($array), FALSE);
Это также (рекурсивно) преобразует все ваши вспомогательные массивы в объекты, которые вы можете или не захотите. К сожалению, он имеет производительность
вы можете просто использовать литье типов для преобразования массива в объект.
// *convert array to object* Array([id]=> 321313[username]=>shahbaz)
$object = (object) $array_name;
//now it is converted to object and you can access it.
echo $object->username;
Быстрый взлом:
// assuming $var is a multidimensional array
$obj = json_decode (json_encode ($var), FALSE);
Не красиво, но работает.
Вот три способа:
Подделка реального объекта:
class convert
{
public $varible;
public function __construct($array)
{
$this = $array;
}
public static function toObject($array)
{
$array = new convert($array);
return $array;
}
}
Преобразуйте массив в объект, отбросив его на объект:
$array = array(
// ...
);
$object = (object) $array;
Вручную преобразовать массив в объект:
$object = object;
foreach ($arr as $key => $value) {
$object->{$key} = $value;
}
Простым способом будет
$object = (object)$array;
Но это не то, что вы хотите. Если вы хотите объекты, которые хотите чего-то достичь, но которые отсутствуют в этом вопросе. Использование объектов только для использования объектов не имеет смысла.
Его путь к простому. Это также создаст объект для рекурсивных массивов:
$object = json_decode(json_encode((object) $yourArray), FALSE);
В зависимости от того, где вам это нужно и как получить доступ к объекту, существуют разные способы сделать это.
Например: просто введите его
$object = (object) $yourArray;
Тем не менее, наиболее совместимым является использование метода утилиты (еще не части PHP), который реализует стандартное кастинг PHP на основе строки, которая указывает тип (или игнорируя его просто де-ссылку на значение):
/**
* dereference a value and optionally setting its type
*
* @param mixed $mixed
* @param null $type (optional)
*
* @return mixed $mixed set as $type
*/
function rettype($mixed, $type = NULL) {
$type === NULL || settype($mixed, $type);
return $mixed;
}
Пример использования в вашем случае (Онлайн-демонстрация):
$yourArray = Array('status' => 'Figure A. ...');
echo rettype($yourArray, 'object')->status; // prints "Figure A. ..."
Нет встроенного метода для этого, насколько я знаю, но это так же просто, как простой цикл:
$obj= new stdClass();
foreach ($array as $k=> $v) {
$obj->{$k} = $v;
}
Вы можете изложить это, если вам нужно, чтобы рекурсивно построить ваш объект.
На самом деле, если вы хотите использовать это с многомерными массивами, вы хотели бы использовать некоторую рекурсию.
static public function array_to_object(array $array)
{
foreach($array as $key => $value)
{
if(is_array($value))
{
$array[$key] = self::array_to_object($value);
}
}
return (object)$array;
}
Я бы определенно пошел с таким чистым способом:
<?php
class Person {
private $name;
private $age;
private $sexe;
function __construct ($payload)
{
if (is_array($payload))
$this->from_array($payload);
}
public function from_array($array)
{
foreach(get_object_vars($this) as $attrName => $attrValue)
$this->{$attrName} = $array[$attrName];
}
public function say_hi ()
{
print "hi my name is {$this->name}";
}
}
print_r($_POST);
$mike = new Person($_POST);
$mike->say_hi();
?>
если вы отправляете:
вы получите следующее:
Я обнаружил, что это более логичное сравнение приведенных выше ответов из "Объектов" должно использоваться с целью их создания (инкапсулированные милые маленькие объекты).
Также использование get_object_vars гарантирует, что в управляемом объекте не создаются дополнительные атрибуты (вам не нужен автомобиль с фамилией, а также человек, ведущий 4 колеса).
Вы также можете использовать ArrayObject, например:
<?php
$arr = array("test",
array("one"=>1,"two"=>2,"three"=>3),
array("one"=>1,"two"=>2,"three"=>3)
);
$o = new ArrayObject($arr);
echo $o->offsetGet(2)["two"],"\n";
foreach ($o as $key=>$val){
if (is_array($val)) {
foreach($val as $k => $v) {
echo $k . ' => ' . $v,"\n";
}
}
else
{
echo $val,"\n";
}
}
?>
//Output:
2
test
one => 1
two => 2
three => 3
one => 1
two => 2
three => 3
рекурсия - ваш друг:
function __toObject(Array $arr) {
$obj = new stdClass();
foreach($arr as $key=>$val) {
if (is_array($val)) {
$val = __toObject($val);
}
$obj->$key = $val;
}
return $obj;
}
Немного сложная, но легко расширяемая техника:
Предположим, у вас есть массив
$a = [
'name' => 'ankit',
'age' => '33',
'dob' => '1984-04-12'
];
Предположим, у вас есть класс Person, который может иметь больше или меньше атрибутов из этого массива. например
class Person
{
private $name;
private $dob;
private $age;
private $company;
private $city;
}
Если вы все еще хотите изменить свой массив на объект person. Вы можете использовать ArrayIterator Class.
$arrayIterator = new \ArrayIterator($a); // Pass your array in the argument.
Теперь у вас есть объект-итератор.
Создайте класс, расширяющий класс FilterIterator; где вы должны определить абстрактный метод принять. Следуй примеру
class PersonIterator extends \FilterIterator
{
public function accept()
{
return property_exists('Person', parent::current());
}
}
Вышеуказанная имплементация будет связывать свойство, только если оно существует в классе.
Добавьте еще один метод в классе PersonIterator
public function getObject(Person $object)
{
foreach ($this as $key => $value)
{
$object->{'set' . underscoreToCamelCase($key)}($value);
}
return $object;
}
Убедитесь, что в вашем классе определены мутаторы. Теперь вы готовы вызывать эти функции там, где вы хотите создать объект.
$arrayiterator = new \ArrayIterator($a);
$personIterator = new \PersonIterator($arrayiterator);
$personIterator->getObject(); // this will return your Person Object.
Тот, который я использую (это член класса):
const MAX_LEVEL = 5; // change it as needed
public function arrayToObject($a, $level=0)
{
if(!is_array($a)) {
throw new InvalidArgumentException(sprintf('Type %s cannot be cast, array expected', gettype($a)));
}
if($level > self::MAX_LEVEL) {
throw new OverflowException(sprintf('%s stack overflow: %d exceeds max recursion level', __METHOD__, $level));
}
$o = new stdClass();
foreach($a as $key => $value) {
if(is_array($value)) { // convert value recursively
$value = $this->arrayToObject($value, $level+1);
}
$o->{$key} = $value;
}
return $o;
}
Легко:
$object = json_decode(json_encode($array));
Пример:
$array = array(
'key' => array(
'k' => 'value',
),
'group' => array('a', 'b', 'c')
);
$object = json_decode(json_encode($array));
Тогда справедливо следующее:
$object->key->k === 'value';
$object->group === array('a', 'b', 'c')
используйте эту функцию, которую я сделал:
function buildObject($class,$data){
$object = new $class;
foreach($data as $key=>$value){
if(property_exists($class,$key)){
$object->{'set'.ucfirst($key)}($value);
}
}
return $object;
}
Использование:
$myObject = buildObject('MyClassName',$myArray);
Для этого требуется PHP7, потому что я решил использовать лямбда-функцию для блокировки "innerfunc" в основной функции. Лямбда-функция называется рекурсивно, поэтому необходимо: "использовать (& $innerfunc)". Вы можете сделать это в PHP5, но не можете скрыть innerfunc.
function convertArray2Object($defs) {
$innerfunc = function ($a) use ( &$innerfunc ) {
return (is_array($a)) ? (object) array_map($innerfunc, $a) : $a;
};
return (object) array_map($innerfunc, $defs);
}
Вы также можете сделать это, добавив (объект) слева от переменной для создания нового объекта.
<?php
$a = Array
( 'status' => " text" );
var_dump($a);
$b = (object)$a;
var_dump($b);
var_dump($b->status);
Использование json_encode является проблематичным из-за того, что он обрабатывает данные, отличные от UTF-8. Стоит отметить, что метод json_encode/json_encode также оставляет неассоциативные массивы в виде массивов. Это может быть или не быть тем, что вы хотите. Недавно мне было необходимо обновить функциональность этого решения, но без использования функций json_. Вот что я придумал:
/**
* Returns true if the array has only integer keys
*/
function isArrayAssociative(array $array) {
return (bool)count(array_filter(array_keys($array), 'is_string'));
}
/**
* Converts an array to an object, but leaves non-associative arrays as arrays.
* This is the same logic that `json_decode(json_encode($arr), false)` uses.
*/
function arrayToObject(array $array, $maxDepth = 10) {
if($maxDepth == 0) {
return $array;
}
if(isArrayAssociative($array)) {
$newObject = new \stdClass;
foreach ($array as $key => $value) {
if(is_array($value)) {
$newObject->{$key} = arrayToObject($value, $maxDepth - 1);
} else {
$newObject->{$key} = $value;
}
}
return $newObject;
} else {
$newArray = array();
foreach ($array as $value) {
if(is_array($value)) {
$newArray[] = arrayToObject($value, $maxDepth - 1);
} else {
$newArray[] = $value;
}
}
return $newArray;
}
}
Лучший метод в МИРЕ:)
function arrayToObject($conArray)
{
if(is_array($conArray)){
/*
* Return array converted to object
* Using __FUNCTION__ (Magic constant)
* for recursive call
*/
return (object) array_map(__FUNCTION__, $conArray);
}else{
// Return object
return $conArray;
}
}
Если вы используете разные методы, у вас будут проблемы. Это лучший метод. Вы когда-либо видели.
один вкладыш
$object= json_decode(json_encode($result_array, JSON_FORCE_OBJECT));
CakePHP имеет рекурсивный класс Set:: map, который в основном отображает массив в объект. Возможно, вам придется изменить то, как выглядит массив, чтобы объект выглядел так, как вы хотите.
http://api.cakephp.org/view_source/set/#line-158
В худшем случае вы можете получить несколько идей от этой функции.
Очевидно, что это просто экстраполяция ответов некоторых других людей, но здесь рекурсивная функция, которая преобразует любой мульш-мерный массив в объект:
function convert_array_to_object($array){
$obj= new stdClass();
foreach ($array as $k=> $v) {
if (is_array($v)){
$v = convert_array_to_object($v);
}
$obj->{strtolower($k)} = $v;
}
return $obj;
}
И помните, что если в массиве имелись числовые ключи, в результирующем объекте все еще можно ссылаться с помощью {} (например: $obj->prop->{4}->prop)
Вдохновленный всеми этими кодами, я попытался создать расширенную версию с поддержкой: определенного имени класса, избегайте метода конструктора, шаблона beans и строгого режима (установите только существующие свойства):
class Util {
static function arrayToObject($array, $class = 'stdClass', $strict = false) {
if (!is_array($array)) {
return $array;
}
//create an instance of an class without calling class constructor
$object = unserialize(
sprintf(
'O:%d:"%s":0:{}', strlen($class), $class
)
);
if (is_array($array) && count($array) > 0) {
foreach ($array as $name => $value) {
$name = strtolower(trim($name));
if (!empty($name)) {
if(method_exists($object, 'set'.$name)){
$object->{'set'.$name}(Util::arrayToObject($value));
}else{
if(($strict)){
if(property_exists($class, $name)){
$object->$name = Util::arrayToObject($value);
}
}else{
$object->$name = Util::arrayToObject($value);
}
}
}
}
return $object;
} else {
return FALSE;
}
}
}
Эта функция работает так же, как json_decode(json_encode($arr), false).
function arrayToObject(array $arr)
{
$flat = array_keys($arr) === range(0, count($arr) - 1);
$out = $flat ? [] : new \stdClass();
foreach ($arr as $key => $value) {
$temp = is_array($value) ? $this->arrayToObject($value) : $value;
if ($flat) {
$out[] = $temp;
} else {
$out->{$key} = $temp;
}
}
return $out;
}
$arr = ["a", "b", "c"];
var_export(json_decode(json_encode($arr)));
var_export($this->arrayToObject($arr));
Вывод:
array(
0 => 'a',
1 => 'b',
2 => 'c',
)
array(
0 => 'a',
1 => 'b',
2 => 'c',
)
$arr = [["a" => 1], ["a" => 1], ["a" => 1]];
var_export(json_decode(json_encode($arr)));
var_export($this->arrayToObject($arr));
Вывод:
array(
0 => stdClass::__set_state(array('a' => 1,)),
1 => stdClass::__set_state(array('a' => 1,)),
2 => stdClass::__set_state(array('a' => 1,)),
)
array(
0 => stdClass::__set_state(array('a' => 1,)),
1 => stdClass::__set_state(array('a' => 1,)),
2 => stdClass::__set_state(array('a' => 1,)),
)
$arr = ["a" => 1];
var_export(json_decode($arr));
var_export($this->arrayToObject($arr));
Вывод:
stdClass::__set_state(array('a' => 1,))
stdClass::__set_state(array('a' => 1,))
Вы можете использовать функцию (объект) для преобразования вашего массива в объект.
$arr= [128=> ['status'=>
'Figure A. Facebook \ horizontal scrollbars showing up on a 1024x768 screen resolution.'],
129=>['status'=>'The other day at work, I had some spare time']];
$ArrToObject=(object)$arr;
var_dump($ArrToObject);
Результатом будет объект, который содержит массивы:
object (stdClass) # 1048 (2) {[128] => array (1) {
["status"] => string (87) "Рисунок A. Горизонтальные полосы прокрутки Facebook, отображаемые с разрешением экрана 1024x768." }
[129] => array (1) {["status"] => string (44) "На днях на работе у меня было свободное время"}}
Я сделал это довольно простым способом,
$list_years = array();
$object = new stdClass();
$object->year_id = 1 ;
$object->year_name = 2001 ;
$list_years[] = $object;
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 array_to_object($data)
{
if (is_array($data) || is_object($data))
{
$result= new stdClass();
foreach ($data as $key => $value)
{
$result->$key = array_to_object($value);
}
return $result;
}
return $data;
}
Используя (массив) и (объект) в качестве префикса, вы можете просто преобразовать массив объектов в стандартный массив и наоборот
<?php
//defining an array
$a = array('a'=>'1','b'=>'2','c'=>'3','d'=>'4');
//defining an object array
$obj = new stdClass();
$obj->a = '1';
$obj->b = '2';
$obj->c = '3';
$obj->d = '4';
print_r($a);echo '<br>';
print_r($obj);echo '<br>';
//converting object array to array
$b = (array) $obj;
print_r($b);echo '<br>';
//converting array to object
$c = (object) $a;
print_r($c);echo '<br>';
?>