Comment puis-je convertir un tableau comme celui-ci en objet?

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

Dans le cas le plus simple, il suffit probablement de «transtyper» le tableau en objet:

$object = (object) $array;

Une autre option serait d'instancier une classe standard en tant que variable et de parcourir votre tableau tout en réaffectant les valeurs:

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

Comme l'a souligné Edson Medina , une solution vraiment propre consiste à utiliser les json_fonctions intégrées:

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

Cela convertit également (récursivement) tous vos sous-tableaux en objets, que vous souhaitiez ou non. Malheureusement, ses performances sont de 2 à 3 fois supérieures à l'approche en boucle.

Attention! (merci à Ultra pour le commentaire):

json_decode sur différents environnements convertit les données UTF-8 de différentes manières. Je finis par obtenir des valeurs «240,00» localement et «240» en production - un énorme dissaster. Morover si la conversion échoue, la chaîne est renvoyée comme NULL

vous pouvez simplement utiliser la conversion de type pour convertir un tableau en objet.

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

La manière la plus simple serait

$object = (object)$array;

Mais ce n'est pas ce que tu veux. Si vous voulez des objets, vous voulez réaliser quelque chose, mais cela manque dans cette question. L'utilisation d'objets uniquement pour la raison de l'utilisation d'objets n'a aucun sens.

Piratage rapide:

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

Pas joli, mais ça marche.

Voici trois façons:

1. Faux un vrai objet:

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

2. Convertissez le tableau en objet en le convertissant en objet:

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

3. Convertissez manuellement le tableau en objet:

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

Son chemin vers le simple, cela créera également un objet pour les tableaux récursifs:

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

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

Par exemple: il suffit de le transcrire

$object =  (object) $yourArray;

Cependant, la plus compatible utilise une méthode utilitaire (qui ne fait pas encore partie de PHP) qui implémente la conversion PHP standard basée sur une chaîne qui spécifie le type (ou en l'ignorant simplement en dé-référençant 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. ..."

Celui-ci a fonctionné 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);

Retour :

    [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 le boucler comme:

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

Il n'y a pas de méthode intégrée pour le faire pour autant que je sache, mais c'est aussi simple qu'une simple boucle:

    $obj= new stdClass();

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

Vous pouvez l'exposer si vous en avez besoin pour construire votre objet de manière récursive.

Vous pouvez utiliser la fonction (objet) pour convertir votre tableau en 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:

objet (stdClass) # 1048 (2) {[128] => tableau (1) {

["status"] => string (87) "Figure A. Barres de défilement horizontales de Facebook apparaissant sur une résolution d'écran de 1024x768." }

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

En fait, si vous souhaitez utiliser cela avec des tableaux multidimensionnels, vous voudrez utiliser une récursivité.

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

J'irais certainement avec une manière propre comme ceci:

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

?>

si vous soumettez:

vous obtiendrez ceci:

J'ai trouvé cela plus logique en comparant les réponses ci-dessus des objets devraient être utilisées dans le but pour lequel elles ont été faites (petits objets mignons encapsulés).

L'utilisation de get_object_vars garantit également qu'aucun attribut supplémentaire n'est créé dans l'objet manipulé (vous ne voulez pas d'une voiture ayant un nom de famille, ni d'une personne se comportant à 4 roues).

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

Technique peu compliquée mais facile à étendre:

Supposons que vous ayez un tableau

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

Supposons que vous ayez une classe Person qui peut avoir plus ou moins d'attributs de ce tableau. par exemple

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

Si vous voulez toujours changer votre tableau en objet personne. Vous pouvez utiliser la classe ArrayIterator.

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

Vous avez maintenant un objet itérateur.

Créez une classe étendant la classe FilterIterator; où vous devez définir la méthode abstraite accepter. Suivre l'exemple

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

L'impelmentation ci-dessus ne liera la propriété que si elle existe dans la classe.

Ajoutez une méthode de plus dans la classe PersonIterator

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

Assurez-vous que des mutateurs sont définis dans votre classe. Vous êtes maintenant prêt à appeler ces fonctions à l'endroit où vous souhaitez créer un objet.

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

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

la récursivité est votre amie:

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

    return $obj;
}

Cela nécessite PHP7 car j'ai choisi d'utiliser une fonction lambda pour verrouiller le 'innerfunc' dans la fonction principale. La fonction lambda est appelée récursivement, d'où la nécessité de: "use (& $ innerfunc)". Vous pouvez le faire en PHP5 mais ne pouvez pas masquer le module interne.

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

utilisez cette fonction que j'ai faite:

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

Usage:

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

bon mot

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

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, ce qui suit est vrai:

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

Vous pouvez également le faire en ajoutant (objet) à gauche de la variable pour 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

L'utilisation json_encodeest problématique en raison de la façon dont elle gère les données non UTF-8. Il convient de noter que la méthode json_encode/ json_encodelaisse également les tableaux non associatifs en tant que tableaux. Cela peut ou non être ce que vous voulez. J'étais récemment dans la position de devoir recréer les fonctionnalités de cette solution mais sans utiliser de json_fonctions. Voici ce que j'ai trouvé:

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

Meilleure méthode au 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 des méthodes différentes, vous aurez des problèmes. C'est la meilleure méthode. Vous avez déjà vu.

Tableaux multidimensionnels dans un objet. ce code est utilisé pour la conversion de la méthode try et catch de l'API de recherche 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);
    }

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

CakePHP a une classe Set :: map récursive qui mappe fondamentalement un tableau dans un objet. Vous devrez peut-être modifier l'apparence du tableau afin de donner à l'objet l'apparence souhaitée.

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

Dans le pire des cas, vous pourrez peut-être obtenir quelques idées de cette fonction.

Évidemment, juste une extrapolation des réponses d'autres personnes, mais voici la fonction récursive qui convertira tout tableau à paillis 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 rappelez - vous que si le tableau avait des touches numériques , ils peuvent être référencés encore l'objet résultant à l'aide {}(par exemple: $obj->prop->{4}->prop)

Inspiré par tous ces codes, j'ai essayé de créer une version améliorée avec le support de: nom de classe spécifique, éviter la méthode constructeur, le modèle 'beans' et le mode strict (définir uniquement les propriétés existantes):

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

Code

Cette fonction fonctionne de la même manière 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;
}

Essai

Test 1: réseau plat

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

Production:

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

Production:

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

Production:

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

je l'ai fait de manière assez simple,

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

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