В простейшем случае, вероятно, достаточно «отличить» массив как объект:

 $object = (object) $array; 

Другим вариантом было бы создание стандартного класса в качестве переменной и цикл через массив при повторном присвоении значений:

 $object = new stdClass(); foreach ($array as $key => $value) { $object->$key = $value; } 

Как отметил Эдсон Медина , действительно чистым решением является использование встроенных функций json_ :

 $object = json_decode(json_encode($array), FALSE); 

Это также (рекурсивно) преобразует все ваши вспомогательные массивы в объекты, которые вы можете или не захотите. К сожалению, он имеет производительность в 2-3 раза по сравнению с циклом.

Предупреждение! (спасибо Ultra за комментарий):

json_decode в разных средах преобразует данные UTF-8 по-разному. В итоге я получаю локальные значения «240,00» и «240» на производстве – массивный диссипатор. Morover, если преобразование завершено, строка get возвращается как NULL

вы можете просто использовать кастинг типов для преобразования массива в объект.

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

Вот три способа:

1. Подделка реального объекта:

    class convert { public $varible; public function __construct($array) { $this = $array; } public static function toObject($array) { $array = new convert($array); return $array; } } 

2. Преобразуйте массив в объект, наведя его на объект:

    $array = array( // ... ); $object = (object) $array; 

3. Вручную преобразуйте массив в объект:

    $object = object; foreach ($arr as $key => $value) { $object->{$key} = $value; } 

Быстрый взлом:

 // assuming $var is a multidimensional array $obj = json_decode (json_encode ($var), FALSE); 

Не красиво, но работает.

Легким способом было бы

 $object = (object)$array; 

Но это не то, что вы хотите. Если вы хотите объекты, которые хотите чего-то достичь, но этого не хватает в этом вопросе. Использование объектов только по причине использования объектов не имеет смысла.

В зависимости от того, где вам это нужно и как получить доступ к объекту, есть разные способы сделать это.

Например: просто придумайте это

 $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. ..." 

Его путь к простому. Это также создаст объект для рекурсивных массивов:

 $object = json_decode(json_encode((object) $yourArray), FALSE); 

Это работало для меня

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

Нет никакого встроенного метода, чтобы это сделать, насколько я знаю, но это так же просто, как простой цикл:

  $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 колеса).

рекурсия – ваш друг:

 function __toObject(Array $arr) { $obj = new stdClass(); foreach($arr as $key=>$val) { if (is_array($val)) { $val = __toObject($val); } $obj->$key = $val; } return $obj; } 

Легко:

 $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') 

Вы также можете использовать 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 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); 

Вы также можете сделать это, добавив (объект) слева от переменной для создания нового объекта.

 <?php $a = Array ( 'status' => " text" ); var_dump($a); $b = (object)$a; var_dump($b); var_dump($b->status); 

http://codepad.org/9YmD1KsU

Использование 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; } } 

если вы используете разные методы, у вас будут проблемы. Это лучший метод. Вы когда-либо видели.

Вдохновленный всеми этими кодами, я попытался создать расширенную версию с поддержкой: определенного имени класса, избежать метода конструктора, шаблона 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's 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; } 

тестирование

Тест 1: Плоский массив

 $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', ) 

Тест 2: Массив объектов

 $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,)), ) 

Тест 3: Объект

 $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,)) 

Небольшая сложная, но простая в использовании техника:

Предположим, у вас есть массив

 $a = [ 'name' => 'ankit', 'age' => '33', 'dob' => '1984-04-12' ]; 

Предположим, у вас есть класс человека, который может иметь больше или меньше атрибутов из этого массива. например

 class Person { private $name; private $dob; private $age; private $company; private $city; } 

Если вы все еще хотите изменить свой массив на объект person. Вы можете использовать класс ArrayIterator.

 $arrayIterator = new \ArrayIterator($a); // Pass your array in the argument. 

Теперь у вас есть объект итератора.

Создайте класс, расширяющий класс FilterIterator; где вы должны определить прием абстрактного метода. Следовать примеру

 class PersonIterator extends \FilterIterator { public function accept() { return property_exits('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. 

один лайнер

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

я сделал это довольно простым способом,

  $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>'; ?> 

Я использую следующее для разбора ассоциативных массивов файлов Ямл в состояние объекта.

Это проверяет все предоставленные массивы, если есть объекты, скрывающиеся там, и превращает их также в объекты.

  /** * Makes a config object from an array, making the first level keys properties a new object. * Property values are converted to camelCase and are not set if one already exists. * @param array $configArray Config array. * @param boolean $strict To return an empty object if $configArray is not an array * @return stdObject The config object */ public function makeConfigFromArray($configArray = [],$strict = true) { $object = new stdClass(); if (!is_array($configArray)) { if(!$strict && !is_null($configArray)) { return $configArray; } return $object; } foreach ($configArray as $name => $value) { $_name = camel_case($name); if(is_array($value)) { $makeobject = true; foreach($value as $key => $val) { if(is_numeric(substr($key,0,1))) { $makeobject = false; } if(is_array($val)) { $value[$key] = $this->makeConfigFromArray($val,false); } } if($makeobject) { $object->{$name} = $object->{$_name} = $this->makeConfigFromArray($value,false); } else { $object->{$name} = $object->{$_name} = $value; } } else { $object->{$name} = $object->{$_name} = $value; } } return $object; } 

Это превращает ямль, сконфигурированный как

 fields: abc: type: formfield something: - a - b - c - d: foo: bar 

к массиву, состоящему из:

 array:1 [ "fields" => array:1 [ "abc" => array:2 [ "type" => "formfield" "something" => array:4 [ 0 => "a" 1 => "b" 2 => "c" 3 => array:1 [ "d" => array:1 [ "foo" => "bar" ] ] ] ] ] ] 

к объекту:

 {#325 +"fields": {#326 +"abc": {#324 +"type": "formfield" +"something": array:4 [ 0 => "a" 1 => "b" 2 => "c" 3 => {#328 +"d": {#327 +"foo": "bar" } } ] } } } 

Для этого требуется 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); }