Comment convertir un tableau en objet en PHP?


367

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
    )

4
Quel type d'objet voulez-vous obtenir précisément? Ce que je veux dire, c'est: quels devraient être les attributs?
Pascal MARTIN

dans une boucle, il devrait tous les deux parce que le statut est un tableau de données donc les deux sont printet
streetparade

Je ne sais pas quand, mais cela fonctionne:$a = (object)['hello' => 'world'];
Nishchal Gautam

Réponses:


588

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


41
"car les variables ne peuvent pas commencer par des nombres", oui elles peuvent: $ object -> {3} = 'xyz';
chelmertz

11
"a un résultat de performance de 2 à 3". Ce qui est une comparaison injuste, car cette dernière méthode renvoie des objets récursifs, tandis que l'approche en boucle sans autres conditions (comme dans la réponse de @streetparade) ne convertit que le premier niveau.
feeela

8
@feeela Je ne pense pas que ce soit injuste du tout. J'ai mentionné qu'il effectue la conversion de manière récursive. En outre, le résultat de performance
2-3x a été obtenu

6
ATTENTION! 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
Szymon Toda

1
Remarque lors de l'utilisation des fonctions json_ *: les références (par exemple à d'autres tableaux) stockées dans le tableau d'origine seront dupliquées dans ce cas. Supposons que la clé xdu tableau contient une référence à un autre tableau. Ensuite, $object->xaprès l'exécution de votre one-liner, il y aura un double de $array['x'], et non plus une référence au tableau d'origine. Cela peut être inoffensif dans certaines applications, mais pour les grands tableaux, cela gaspille de la mémoire et peut gâcher l'exécution si la référence est utilisée plus tard.
The Coprolal

153

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;

107

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.


2
ne fonctionne pas, je l'ai fait avant de poser la question ici, donc il doit y avoir une autre façon de le faire
streetparade

20
Pourquoi doit-il donner sa raison de vouloir utiliser des objets? Je ne pense pas que ce soit pertinent pour la façon dont cela se fait. Peut-être qu'il a besoin de les json_encode, ou de les sérialiser? Il pourrait y avoir des dizaines de raisons de le faire.
zombat

hmm .. j'ai regardé la sortie du navigateur, il ressemble à cet objet (stdClass) # 150 (130) {[0] => array (1) {["status"] => string (130) "Enfin Mac et Les utilisateurs de Linux n'ont pas à se sentir comme des citoyens de seconde classe dans Chrome Land: ils ont la version bêta officielle… "} officiellement c'est un objet, mais comment répéter cela pour que je puisse accéder au statut comme $ obj-> status n'importe quelle idée ?
streetparade

zombat, l'encodage JSON n'est pas une raison pour utiliser un objet, il y a un indicateur à json_encode () pour utiliser les objets. avec sérialiser, il faudrait un type d'objet spécifique attendu par le récepteur. Et en général, j'essaie d'aider avec le problème réel . pour moi, cette question implique qu'il y a une erreur architecturale ailleurs.
johannes

gentil, travaillez avec le tableau laravel pour résoudre le problème
Anthony Kal

105

Piratage rapide:

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

Pas joli, mais ça marche.


2
J'adore cette solution, utiliser des fonctions intégrées au lieu de celles définies par l'utilisateur est toujours plus rapide, et celle-ci fonctionne très bien. Merci pour le conseil.
aknatn

@Oddant Cela résout le problème mentionné ci-dessus (convertir un tableau en objet). Votre diatribe doit être dirigée vers le poste principal, pas ma solution.
Edson Medina

@EdsonMedina Je l'ai fait, mon message est cependant trop bas.
vdegenne

1
@Oddant, pour être juste envers @EdsonMedina, la question d'origine ne spécifie pas de quelle visibilité les attributs ont besoin, et puisque OP n'utilise pas $thisdans les commentaires qui suivent comme accesseur, il est fortement implicite qu'il / elle désire une stdClassinstance en sortie et non une classe définie par l'utilisateur telle que votre réponse utilise. Je suis d'accord sur l'élégance de cette solution, mais malheureusement, c'est un modèle assez couramment utilisé pour résoudre ce problème avec les tableaux imbriqués où la conversion en objet ne fonctionnera pas. Il est également possible qu'OP utilise une interface qui requiert et objecte en entrée et non un tableau.
DeaconDesperado

3
N'oubliez pas qu'en utilisant cette méthode, vous perdrez tout sauf les types de base. DateTime sera par exemple le convertisseur stdObject.
Denis Pshenov

97

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

2
hmm merci mais votre classe de visage donne l'erreur suivante Erreur fatale: Impossible de réaffecter $ this dans /var/www/bot/inc/twitter-bot.php sur la ligne 10
streetparade

1
et typcasint @ reference n'est pas une bonne idée, même si cela ne fonctionnerait pas, voici ce que j'ai obtenu T_OBJECT_CAST inattendu, en attendant T_NEW ou T_STRING ou T_VARIABLE ou '$'
streetparade

2
$ array = & (object) $ array == belle implémentation KISS!
mate64

16
Pourquoi voudrait-on utiliser une méthode différente de 2)? Y a-t-il des inconvénients?
Yogu

7
le transtypage d'un tableau en objet ne fonctionne pas sur les tableaux imbriqués
minhajul

34

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

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

4
passer falseà json_decode()renverra un tableau associatif.
Rust

3
@ user3284463 Le passage trueà json_decoderetournera un tableau associatif, falseest la valeur par défaut et retournera une StdClassinstance.
Elliot Reed

24

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

17

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

Mais celui-ci est environ 500% plus lent (testé) que la conversion de type: $ obj = (object) $ array;
xZero

@xZero mais $obj = (object) $array;ne fonctionne pas pour les tableaux multidimensionnels.
Jeff Puckett

15

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.


15

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


9

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

8

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:

formulaire

vous obtiendrez ceci:

Mike

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


Pourquoi n'utilisez-vous pas $ attr_value au lieu de $ array [$ attr_name]; dans votre fonction publique from_array ($ array)
Sakkeer Hussain

7

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

1
À mon avis, cela devrait devenir la meilleure réponse. Plus d' infos Herre: php.net/manual/en/arrayobject.construct.php
Julian

7

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

7

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. 

6

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

6

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

5

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

5

bon mot

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

1
Notez que les références (par exemple à d'autres tableaux) stockées dans le tableau d'origine seront dupliquées par ce one-liner. Supposons que la clé xdu tableau contient une référence à un autre tableau. Ensuite, $object->xaprès l'exécution de votre one-liner sera un doublon de $result_array['x'], pas le tableau identique.
The Coprolal

4

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

1
Je pense que c'est une solution de contournement. Pourquoi encoder un tableau en json puis le décoder? Ce n'est pas une décision optimale pour moi.
Julian

1
@Julian, parce qu'il fonctionne récursivement, le fait d'une manière correctement définie et suffisamment fiable ("standard"), et est également assez rapide pour être une bonne alternative à la magie aléatoire des singes codée à la main.
Sz.

3

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


1
peut-être vaut-il la peine de mentionner que cela s'appelle "casting" ou "casting de type": php.net/manual/en/… et le comportement de (object) array () est documenté ici: php.net/manual/en/…
Pete

2

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

2

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.


2

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

2

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

1

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.


1

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


1

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

1

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

0

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;
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.