Come posso convertire un array come questo in oggetto?

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

Nel caso più semplice, è probabilmente sufficiente "lanciare" l'array come oggetto:

$object = (object) $array;

Un'altra opzione sarebbe quella di creare un'istanza di una classe standard come variabile e di eseguire il ciclo dell'array durante la riassegnazione dei valori:

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

Come sottolineato da Edson Medina , una soluzione davvero pulita è quella di utilizzare le json_funzioni integrate:

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

Anche questo (ricorsivamente) converte tutti i tuoi array secondari in oggetti, che potresti desiderare o meno. Sfortunatamente ha un impatto sulle prestazioni 2-3x rispetto all'approccio loop.

Avvertimento! (grazie a Ultra per il commento):

json_decode su diversi ambienti converte i dati UTF-8 in diversi modi. Alla fine ottengo valori "240,00" localmente e "240" in produzione: un enorme dissaster. Più scuro se la conversione fallisce, la stringa viene restituita come NULL

puoi semplicemente usare il tipo casting per convertire un array in oggetto.

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

Il modo semplice sarebbe

$object = (object)$array;

Ma non è quello che vuoi. Se vuoi oggetti, vuoi ottenere qualcosa, ma questo manca in questa domanda. L'uso degli oggetti solo per la ragione dell'uso degli oggetti non ha senso.

Hack rapido:

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

Non carino, ma funziona.

Ecco tre modi:

1. Falso un oggetto reale:

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

2. Converti l'array in un oggetto lanciandolo in un oggetto:

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

3. Converti manualmente l'array in un oggetto:

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

Il suo modo semplice, questo creerà un oggetto anche per array ricorsivi:

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

A seconda di dove è necessario e come accedere all'oggetto, esistono diversi modi per farlo.

Ad esempio: basta digitarlo

$object =  (object) $yourArray;

Tuttavia, il più compatibile sta usando un metodo di utilità (non ancora parte di PHP) che implementa il casting PHP standard basato su una stringa che specifica il tipo (o ignorandolo semplicemente facendo riferimento al valore):

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

L'esempio di utilizzo nel tuo caso ( Demo online ):

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

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

Questo ha funzionato per me

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

utilizzo:

$myobject = arrayToObject($array);
print_r($myobject);

ritorna :

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

come al solito puoi fare il loop come:

foreach($myobject as $obj)
{
  echo $obj->status;
}

Non esiste un metodo integrato per farlo per quanto ne so, ma è facile come un semplice ciclo:

    $obj= new stdClass();

    foreach ($array as $k=> $v) {
        $obj->{$k} = $v;
    }

Puoi spiegarlo se ne hai bisogno per costruire ricorsivamente il tuo oggetto.

È possibile utilizzare la funzione (oggetto) per convertire l'array in un oggetto.

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

Il risultato sarà un oggetto che contiene array:

oggetto (stdClass) # 1048 (2) {[128] => array (1) {

["status"] => string (87) "Figura A. Le barre di scorrimento orizzontali di Facebook che appaiono su una risoluzione dello schermo di 1024x768." }

[129] => array (1) {["status"] => string (44) "L'altro giorno al lavoro, ho avuto del tempo libero"}}

In realtà, se si desidera utilizzarlo con array multidimensionali, è consigliabile utilizzare una ricorsione.

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

Vorrei assolutamente andare con un modo pulito come questo:

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

?>

se invii:

otterrai questo:

Ho trovato questo più logico, confrontando le risposte di cui sopra da Oggetti dovrebbe essere usato per lo scopo per cui sono stati creati (piccoli oggetti incapsulati).

Anche l'utilizzo di get_object_vars garantisce che non vengano creati altri attributi nell'oggetto manipolato (non si desidera che un'auto abbia un cognome, né una persona che si comporti a 4 ruote).

È inoltre possibile utilizzare un ArrayObject, ad esempio:

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

Quello che uso (è un membro della classe):

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

Tecnica un po 'complicata ma facile da estendere:

Supponiamo di avere un array

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

Supponiamo di avere una classe Person che può avere più o meno attributi da questo array. per esempio

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

Se vuoi ancora cambiare l'array nell'oggetto persona. È possibile utilizzare la classe ArrayIterator.

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

Ora hai un oggetto iteratore.

Creare una classe che estende la classe FilterIterator; dove devi definire il metodo astratto accetta. Segui l'esempio

class PersonIterator extends \FilterIterator
{
    public function accept()
    {
        return property_exists('Person', parent::current());
    }
}

L'impelmentazione di cui sopra vincolerà la proprietà solo se esiste nella classe.

Aggiungi un altro metodo nella classe PersonIterator

public function getObject(Person $object)
{
        foreach ($this as $key => $value)
        {
            $object->{'set' . underscoreToCamelCase($key)}($value);
        }
        return $object;
}

Assicurati di avere mutatori definiti nella tua classe. Ora sei pronto per chiamare queste funzioni dove vuoi creare l'oggetto.

$arrayiterator = new \ArrayIterator($a);
$personIterator = new \PersonIterator($arrayiterator);

$personIterator->getObject(); // this will return your Person Object. 

ricorsione è tuo amico:

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

    return $obj;
}

Ciò richiede PHP7 perché ho scelto di usare una funzione lambda per bloccare "innerfunc" all'interno della funzione principale. La funzione lambda viene chiamata in modo ricorsivo, da qui la necessità di: "use (& $ innerfunc)". Potresti farlo in PHP5 ma non puoi nascondere il funzionamento interno.

function convertArray2Object($defs) {
    $innerfunc = function ($a) use ( &$innerfunc ) {
       return (is_array($a)) ? (object) array_map($innerfunc, $a) : $a; 
    };
    return (object) array_map($innerfunc, $defs);
}

usa questa funzione che ho creato:

function buildObject($class,$data){
    $object = new $class;
    foreach($data as $key=>$value){
        if(property_exists($class,$key)){
            $object->{'set'.ucfirst($key)}($value);
        }
    }
    return $object;
}

Uso:

$myObject = buildObject('MyClassName',$myArray);

una fodera

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

Facile:

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

Esempio:

$array = array(
    'key' => array(
        'k' => 'value',
    ),
    'group' => array('a', 'b', 'c')
);

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

Quindi, è vero quanto segue:

$object->key->k === 'value';
$object->group === array('a', 'b', 'c')

Puoi anche farlo aggiungendo (oggetto) a sinistra della variabile per creare un nuovo oggetto.

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

http://codepad.org/9YmD1KsU

L'uso json_encodeè problematico a causa del modo in cui gestisce i dati non UTF-8. Vale la pena notare che il metodo json_encode/ json_encodelascia anche array non associativi come array. Questo può o meno essere quello che vuoi. Recentemente ero nella posizione di dover ricreare la funzionalità di questa soluzione ma senza usare le json_funzioni. Ecco cosa mi è venuto in mente:

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

Il metodo migliore nel mondo :)

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

se usi metodi diversi avrai problemi. Questo è il metodo migliore. L'hai mai visto

Matrici multidimensionali in un oggetto. questo codice viene utilizzato per la conversione del metodo try and catch dell'API di ricerca 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);
    }

Puoi usare 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 ha una classe ricorsiva Set :: map che fondamentalmente mappa un array in un oggetto. Potrebbe essere necessario modificare l'aspetto dell'array per rendere l'oggetto come desiderato.

http://api.cakephp.org/view_source/set/#line-158

Nel peggiore dei casi, potresti essere in grado di ottenere alcune idee da questa funzione.

Ovviamente solo un'estrapolazione delle risposte di altre persone, ma ecco la funzione ricorsiva che convertirà qualsiasi matrice tridimensionale in un oggetto:

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

E ricorda che se la matrice ha tasti numerici possono ancora essere fatto riferimento nel oggetto risultante utilizzando {}(ad esempio: $obj->prop->{4}->prop)

Ispirato da tutti questi codici, ho cercato di creare una versione migliorata con supporto a: nome di classe specifico, metodo di costruttore evitato, modello 'bean' e modalità rigorosa (imposta solo proprietà esistenti):

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

Codice

Questa funzione funziona come 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;
}

analisi

Test 1: matrice piatta

$arr = ["a", "b", "c"];
var_export(json_decode(json_encode($arr)));
var_export($this->arrayToObject($arr));

Produzione:

array(
    0 => 'a',
    1 => 'b',
    2 => 'c',
)
array(
    0 => 'a',
    1 => 'b',
    2 => 'c',
)

Test 2: matrice di oggetti

$arr = [["a" => 1], ["a" => 1], ["a" => 1]];
var_export(json_decode(json_encode($arr)));
var_export($this->arrayToObject($arr));

Produzione:

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

Test 3: oggetto

$arr = ["a" => 1];
var_export(json_decode($arr));
var_export($this->arrayToObject($arr));

Produzione:

stdClass::__set_state(array('a' => 1,))
stdClass::__set_state(array('a' => 1,))

l'ho fatto in modo abbastanza semplice,

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

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