web-dev-qa-db-fra.com

Comment convertir un tableau en objet en PHP?

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

 [128] => Tableau 
 (
 [status] => Figure A .
 Les barres de défilement horizontales de Facebook apparaissant sur une résolution d'écran de 1024x768 .
) 

 [129] => Tableau 
 (
 [status] => L'autre jour au travail, j'avais un peu de temps libre 
) 

)
phparraysobjectcasting
286
streetparade

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

résultats : 

    [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 mettre en boucle comme: 

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

Dans le cas le plus simple, il suffit probablement de "transformer" 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 en réaffectant les valeurs:

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

Comme Edson Medina a souligné, une solution vraiment propre consiste à utiliser les fonctions intégrées json_:

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

Ceci convertit également (de manière récursive) tous vos sous-tableaux en objets, que vous souhaitiez ou non. Malheureusement, il a une approche 2-3x performance over the looping.

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» sur la production - dissaster massive. Morover si la conversion échoue, la chaîne get est renvoyée sous la forme NULL

463
jlb

vous pouvez simplement utiliser le transtypage 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;
144
Shahbaz

Voici trois manières:

  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. Convertissez le tableau en objet en le transformant en objet:

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

  3. Convertissez manuellement le tableau en objet:

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

Hack rapide:

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

Pas joli, mais ça marche.

90
Edson Medina

Le moyen le 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. Utiliser des objets uniquement pour la raison d'utiliser des objets n'a aucun sens.

77
johannes

Sa façon de faire simple, cela créera également un objet pour les tableaux récursifs

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

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

Par exemple: il suffit de le transtyper

$object =  (object) $yourArray;

Cependant, le plus compatible utilise une méthode utilitaire (qui ne fait pas encore partie de PHP) qui implémente le transtypage standard PHP basé sur une chaîne spécifiant le type (ou en l'ignorant (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;
}

Exemple d'utilisation dans votre cas ( Démo en ligne ):

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

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

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

    $obj= new stdClass();

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

Vous pouvez expliquer cela si vous en avez besoin pour construire votre objet de manière récursive.

15
zombat

En fait, si vous voulez utiliser cela avec des tableaux multidimensionnels, vous voudrez utiliser une certaine récursion.

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
Nezzy

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 contenant des tableaux:

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

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

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

6
Noha Shehab

J'irais définitivement avec une méthode propre comme celle-ci:

<?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 de comparer les réponses ci-dessus de Objets devrait être utilisé dans le but pour lequel ils ont été créés (petits objets encapsulés mignons).

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

6
vdegenne

récursion est ton ami:

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

    return $obj;
}
5
minhajul

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

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
5
slevy1

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 pouvant 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 ArrayIterator Class. 

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

Maintenant, vous avez un objet itérateur. 

Créez une classe qui étend la classe FilterIterator; où vous devez définir la méthode abstraite accept. 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. 

Ajouter une autre méthode 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à où vous voulez créer un objet.

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

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

utiliser 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);
4
Douraid Arfaoui

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

Alors, ce qui suit est vrai:

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

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 vous ne pouvez pas cacher le 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);
}
3
Chris Jeffries

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

2
fedmich

bon mot 

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

Meilleure méthode dans le 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
zezeron

L'utilisation de json_encode est problématique en raison de la manière dont il traite les données non UTF-8. Il est à noter que la méthode json_encode/json_encode laisse également les tableaux non associatifs en tant que tableaux. Cela peut être ou ne pas ê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 les fonctions json_. Voici ce que je suis venu avec:

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

Évidemment, il ne s'agit que d'une extrapolation des réponses de certaines personnes, mais voici la fonction récursive qui convertira n'importe quel tableau de dimensions en 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 clés numériques, ils peuvent toujours être référencés dans l'objet résultant en utilisant {} (par exemple: $obj->prop->{4}->prop)

1
Ben D

Inspiré par tous ces codes, j'ai essayé de créer une version améliorée prenant en charge: un nom de classe spécifique, une méthode de constructeur à éviter, 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
celsowm

CakePHP a une classe Set :: map récursive qui mappe un tableau dans un objet. Vous devrez peut-être modifier l'apparence du tableau pour que l'objet ressemble à celui que vous souhaitez.

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
Dooltaz

Code

Cette fonction a la même fonction 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: tableau plat

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

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

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

Sortie:

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

Tableaux multidimensionnels dans un objet. Ce code est utilisé pour la conversion de la méthode try and 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);
    }
0
Krishnamoorthy Acharya
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;
}
0
Mehmet Ali Ulusan

En utilisant (array) et (object) comme préfixe, vous pouvez simplement convertir un tableau d'objet en tableau standard et vice-vers

<?php
//defining an array
$a = array('a'=>'1','b'=>'2','c'=>'3','d'=>'4');

//defining an object array
$obj = new stdClass();
$obj->a = '1';
$obj->b = '2';
$obj->c = '3';
$obj->d = '4';

print_r($a);echo '<br>';
print_r($obj);echo '<br>';

//converting object array to array
$b = (array) $obj;
print_r($b);echo '<br>';

//converting array to object
$c = (object) $a;
print_r($c);echo '<br>';
?>
0
rb vishnu

J'utilise ce qui suit pour analyser les tableaux associatifs de fichiers Yaml dans un état d'objet.

Ceci vérifie tous les tableaux fournis si des objets s'y cachent et les transforme également 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 transforme un yaml configuré en tant que

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

à un tableau composé 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"
          }
        }
      ]
    }
  }
}
0
Tschallacka

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

je l'ai fait d'une manière assez simple, 

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

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