Comment faire pour convertir un tableau d'objet en PHP?

Dans le cas le plus simple, c'est probablement suffisant pour "mouler" le tableau comme un objet:

$object = (object) $array;

Une autre option serait d'instancier une classe standard comme une variable, et la boucle dans votre tableau, tout en re-affectation de valeurs:

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

Comme Edson Médina souligné, vraiment propre solution est d'utiliser le haut- json_ fonctions:

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

Ce également (de manière récursive) permet de convertir tous vos sous des tableaux dans des objets, que vous pouvez ou ne souhaitez pas. Malheureusement, il a un 2-3x performances sur la boucle de la démarche.

Avertissement! (merci à Ultra pour le commentaire):

json_decode sur les différents environnements convertit en UTF-8 les données de différentes façons. Je finis par arriver sur des valeurs '240.00" localement et '240' sur la production massive dissaster. Plus si la conversion échoue chaîne est retourné NULL

Rapide hack:

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

Pas assez, mais les œuvres.

Voici trois façons:

1. Faux un objet réel:

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

2. Convertir le tableau en un objet par moulage d'un objet:

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

3. Manuellement convertir le tableau en objet:

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

Selon l'endroit où vous avez besoin et comment accéder à l'objet il y a différentes façons de le faire.

Par exemple: il suffit de transtypage il

$object =  (object) $yourArray;

Cependant, le plus compatible est d'utiliser un utilitaire de méthode (pas encore partie de PHP) qui implémente le standard de PHP casting basé sur une chaîne qui spécifie le type (ou en l'ignorant juste de références de la valeur):

/**
 * 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'exemple d'utilisation dans votre cas (Démo En Ligne):

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

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

Ce a travaillé pour moi

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

utilisation :

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

retourne :

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

comme d'habitude, vous pouvez faire une boucle comme:

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

Vous pouvez utiliser l' (objet) de la fonction de convertir votre tableau dans un objet.

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

Le résultat sera un objet qui contient des tableaux:

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

["status"]=>
chaîne(87) "la Figure A. Facebook 's barres de défilement horizontal affiche sur un écran 1 024 x 768 de résolution." }

[129]=> array(1) {
["status"]=>
string(44) "L'autre jour, au travail, j'avais un peu de temps libre" } }

Vous pouvez également utiliser un ArrayObject, par exemple:

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

Celui que j'utilise (c'est un membre de la 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;
}

utiliser cette fonction que j'ai fait:

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

Utilisation:

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

Facile:

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

Exemple:

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

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

Ensuite, la suivante est vraie:

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

Vous pourriez aussi le faire par l'ajout de (objet) sur la gauche de la variable à créer un nouvel objet.

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

http://codepad.org/9YmD1KsU

Meilleure Méthode du MONDE 🙂

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

si vous utilisez de différentes méthodes, vous aurez des problèmes. C'est la meilleure méthode. Vous avez jamais vu.

Évidemment juste une extrapolation de quelques autres gens de réponses, mais voici la fonction récursive qui permettra de convertir n'importe quel paillis-dimensions tableau en objet:

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

Et n'oubliez pas que si le tableau avait des touches numériques, ils peuvent encore être référencé dans le résultat de l'objet à l'aide de {} (par exemple: $obj->prop->{4}->prop)

Code

Cette fonction fonctionne comme même que 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;
}

Tests

Test 1: tableau Plat

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

De sortie:

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

Test 2: Tableau d'objets

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

De sortie:

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: Objet

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

De sortie:

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

Vous pouvez utiliser la Réflexion:

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

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

J'utilise la suite pour analyser les fichiers Yaml tableaux associatifs dans un état de l'objet.

Celui-ci vérifie tous fourni des tableaux si il y a des objets cachés, et les transforme aussi en objets.

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

Cela s'avère un yaml configuré comme

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

à un tableau constitué de:

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"
          ]
        ]
      ]
    ]
  ]
]

à un objet de:

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