Как я могу преобразовать такой массив в объект?

[128] => Array
    (
        [status] => Figure A.
 Facebook's horizontal scrollbars showing up on a 1024x768 screen resolution.
    )

[129] => Array
    (
        [status] => The other day at work, I had some spare time
    )

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

$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» на производстве - огромный разбойник. Более того, если преобразование не удалось, строка 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;

Простой способ был бы

$object = (object)$array;

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

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

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

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

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

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

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

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

Пример использования в вашем случае ( Online Demo ):

$yourArray = Array('status' => 'Figure A. ...');

echo rettype($yourArray, 'object')->status; // prints "Figure A. ..."

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

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

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

Вы можете использовать функцию (объект) для преобразования вашего массива в объект.

$arr= [128=> ['status'=>
                 'Figure A. Facebook \'s 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) "На днях на работе у меня было свободное время"}}

На самом деле, если вы хотите использовать это с многомерными массивами, вы захотите использовать некоторую рекурсию.

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

Тот, который я использую (это член класса):

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

Немного сложная, но легко расширяемая техника:

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

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

рекурсия твой друг

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

    return $obj;
}

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

используйте эту функцию, которую я сделал:

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

один лайнер

$object= json_decode(json_encode($result_array, JSON_FORCE_OBJECT));

Легко:

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

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

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

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

Многомерные массивы в объект. этот код используется для преобразования метода try и catch API поиска Bing.

try {
        // Perform the Web request and get the JSON response
        $context = stream_context_create($options);
        $results = file_get_contents($url . "?cc=" . $country . "&category=" . $type, false, $context);
        $results = json_decode($results);
        return response()->json($results);
    } catch (\Exception $e) {
        $results = array('value' => array(
                (object) array(
                    "name" => "Unable to Retrive News",
                    "url" => "http://www.sample.com/",
                    "image" => (object) array("thumbnail" => (object) array("contentUrl" => "")),
                    "publishedAt" => "",
                    "description" => "")
            )
        );
        $results = (object) $results;
        return response()->json($results);
    }

Вы можете использовать Reflection:

<?php

$array = ['name'=>'maria','age'=>33];

class Person {

    public $name;
    public $age;

    public function __construct(string $name, string $age){
        $this->name  = $name;
        $this->age = $age;
    }
}

function arrayToObject(array $array, string $class_name){

    $r = new ReflectionClass($class_name);
    $object = $r->newInstanceWithoutConstructor();
    $list = $r->getProperties();
    foreach($list as $prop){
      $prop->setAccessible(true);
      if(isset($array[$prop->name]))
        $prop->setValue($object, $array[$prop->name]);
    } 

    return $object;

}

$pessoa1 = arrayToObject($array, 'Person');
var_dump($pessoa1);

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

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

    $list_years         = array();
    $object             = new stdClass();

    $object->year_id   = 1 ;
    $object->year_name = 2001 ;
    $list_years[]       = $object;