it-swarm.com.de

Wie konvertiere ich ein Array in ein Objekt in PHP?

Wie kann ich ein Array wie dieses in ein Objekt konvertieren?

 [128] => Array 
 (
 [Status] => Abbildung A .
 Die horizontalen Bildlaufleisten von Facebook werden bei einer Bildschirmauflösung von 1024x768 angezeigt .
 [129] => Array 
 (
 [status] => An einem anderen Tag hatte ich etwas Freizeit 
) 

) 
286
streetparade

Dieser hat für mich gearbeitet

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

Verwendungszweck :

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

kehrt zurück :

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

wie üblich kannst du es wie folgt schleifen:

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

Im einfachsten Fall reicht es wahrscheinlich aus, das Array als Objekt "umzuwandeln":

$object = (object) $array;

Eine andere Option wäre, eine Standardklasse als Variable zu instanziieren und das Array zu durchlaufen, während die Werte erneut zugewiesen werden:

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

Wie Edson Medina hervorgehoben hat, ist die Verwendung der integrierten json_-Funktionen eine wirklich saubere Lösung:

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

Dies konvertiert auch (rekursiv) alle Ihre Sub-Arrays in Objekte, die Sie möglicherweise nicht möchten. Leider hat es einen 2-3x Performance-Hit über den Looping-Ansatz.

Warnung! (Danke an Ultra für den Kommentar):

json_decode für verschiedene Umgebungen konvertiert UTF-8-Daten auf verschiedene Arten. Am Ende bekomme ich Werte von "240.00" vor Ort und "240" in der Produktion - massiver Disaster. Wenn die Konvertierung fehlschlägt, wird der String als NULL zurückgegeben

463
jlb

sie können einfach mit Typumwandlung ein Array in ein Objekt konvertieren.

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

Hier gibt es drei Möglichkeiten:

  1. Fake ein echtes Objekt:

    class convert
    {
        public $varible;
    
        public function __construct($array)
        {
            $this = $array;
        }
    
        public static function toObject($array)
        {
            $array = new convert($array);
            return $array;
        }
    }
    
  2. Konvertieren Sie das Array in ein Objekt, indem Sie es in ein Objekt umwandeln:

    $array = array(
        // ...
    );
    $object = (object) $array;
    
  3. Konvertieren Sie das Array manuell in ein Objekt:

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

Schneller Hack:

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

Nicht hübsch, aber funktioniert.

90
Edson Medina

Der einfache Weg wäre

$object = (object)$array;

Aber das willst du nicht. Wenn Sie Objekte wollen, wollen Sie etwas erreichen, aber das fehlt in dieser Frage. Die Verwendung von Objekten nur zum Zweck der Verwendung von Objekten macht keinen Sinn.

77
johannes

Einfacher Weg. Dies erzeugt auch ein Objekt für rekursive Arrays:

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

Je nachdem, wo Sie das benötigen und wie Sie auf das Objekt zugreifen, gibt es verschiedene Möglichkeiten.

Zum Beispiel: einfach typisieren

$object =  (object) $yourArray;

Die am besten kompatible Methode verwendet jedoch eine Utility-Methode (noch nicht Teil von PHP), die Standard-Casting PHP basierend auf einer Zeichenfolge implementiert, die den Typ angibt (oder indem der Wert ignoriert wird, indem der Wert ignoriert wird):

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

Das Anwendungsbeispiel in Ihrem Fall ( Online Demo ):

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

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

Soweit mir bekannt ist, gibt es keine integrierte Methode, aber es ist so einfach wie eine einfache Schleife:

    $obj= new stdClass();

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

Sie können dies erläutern, wenn Sie es benötigen, um Ihr Objekt rekursiv zu erstellen.

15
zombat

Wenn Sie dies mit mehrdimensionalen Arrays verwenden möchten, möchten Sie eine Rekursion verwenden.

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

Mit der (Objekt-) Funktion können Sie Ihr Array in ein Objekt konvertieren.

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

Das Ergebnis ist ein Objekt, das Arrays enthält:

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

["status"] => string (87) "Abbildung A. Die horizontalen Bildlaufleisten von Facebook werden bei einer Bildschirmauflösung von 1024 x 768 angezeigt." }

[129] => array (1) {["status"] => string (44) "Ich hatte neulich bei der Arbeit etwas Freizeit"}}

6
Noha Shehab

Ich würde auf jeden Fall einen sauberen Weg wie folgt gehen:

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

?>

wenn du einreichst:

formulaire

sie werden das bekommen:

mike

Ich fand diesen logischeren Vergleich der obigen Antworten von Objects für den Zweck, für den sie gemacht wurden (eingekapselte niedliche kleine Objekte).

Mit get_object_vars stellen Sie außerdem sicher, dass im manipulierten Objekt keine zusätzlichen Attribute erstellt werden (Sie möchten nicht, dass ein Auto einen Familiennamen hat oder dass sich eine Person mit vier Rädern verhält).

6
vdegenne

rekursion ist dein Freund:

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

Die, die ich benutze (es ist ein Klassenmitglied):

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

Sie können auch ein ArrayObject verwenden, zum Beispiel:

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

Wenig kompliziert, aber leicht zu erweiternde Technik:

Angenommen, Sie haben ein Array 

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

Angenommen, Sie haben eine Person-Klasse, die mehr oder weniger Attribute von diesem Array haben kann. zum Beispiel

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

Wenn Sie Ihr Array immer noch in das Personenobjekt ändern möchten. Sie können ArrayIterator-Klasse verwenden. 

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

Jetzt haben Sie ein Iteratorobjekt. 

Erstellen Sie eine Klasse, die die FilterIterator-Klasse erweitert. wo Sie die abstrakte Methode definieren müssen Folge dem Beispiel

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

Bei der obigen Implementierung wird die Eigenschaft nur dann gebunden, wenn sie in der Klasse vorhanden ist. 

Fügen Sie eine weitere Methode in der Klasse PersonIterator hinzu

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

Stellen Sie sicher, dass in Ihrer Klasse Mutatoren definiert sind. Nun können Sie diese Funktion dort aufrufen, wo Sie ein Objekt erstellen möchten.

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

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

verwenden Sie diese Funktion, die ich gemacht habe:

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

Verwendungszweck:

$myObject = buildObject('MyClassName',$myArray);
4
Douraid Arfaoui

Einfach:

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

Beispiel:

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

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

Dann gilt Folgendes:

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

Dies erfordert PHP7, da ich mich dazu entschieden habe, eine Lambda-Funktion zu verwenden, um die 'innere Funktion' innerhalb der Hauptfunktion zu sperren. Die Lambda-Funktion wird rekursiv aufgerufen, daher muss "use (& $ innerfunc)" verwendet werden. Sie könnten es in PHP5 tun, aber die innere Funktion nicht ausblenden.

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

Sie können dies auch tun, indem Sie links von Variable (object) hinzufügen, um ein neues Objekt zu erstellen.

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

http://codepad.org/9YmD1KsU

2
fedmich

einzeiler 

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

Beste Methode der Welt :)

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

wenn Sie andere Methoden verwenden, haben Sie Probleme. Dies ist die beste Methode. Hast du jemals gesehen.

2
zezeron

Die Verwendung von json_encode ist problematisch, da auf diese Weise nicht UTF-8-Daten verarbeitet werden. Es ist erwähnenswert, dass die Methode json_encode/json_encode auch nichtassoziative Arrays als Arrays belässt. Dies kann oder nicht das sein, was Sie wollen. Ich war kürzlich in der Lage, die Funktionalität dieser Lösung neu zu erstellen, ohne json_-Funktionen zu verwenden. Folgendes habe ich mir ausgedacht:

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

Offensichtlich nur eine Extrapolation der Antworten anderer Leute, aber hier ist die rekursive Funktion, die jedes Mulch-dimensionale Array in ein Objekt konvertiert:

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

Denken Sie daran, dass das Array, wenn es numerische Schlüssel hatte, mit {} noch im resultierenden Objekt referenziert werden kann (zum Beispiel: $obj->prop->{4}->prop).

1
Ben D

Inspiriert von all diesen Codes habe ich versucht, eine erweiterte Version mit Unterstützung für folgende Klassen zu erstellen: Spezifischer Klassenname, Konstruktormethode, 'Beans'-Muster und strikter Modus (nur vorhandene Eigenschaften festlegen):

    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 verfügt über eine rekursive Set :: map-Klasse, die ein Array grundsätzlich einem Objekt zuordnet. Sie müssen möglicherweise das Aussehen des Arrays ändern, damit das Objekt so aussieht, wie Sie es möchten.

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

Im schlimmsten Fall können Sie einige Ideen von dieser Funktion erhalten.

1
Dooltaz

Code

Diese Funktion funktioniert genauso wie 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;
}

Testen

Test 1: Flaches Array

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

Ausgabe:

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

Test 2: Array von Objekten

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

Ausgabe:

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

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

Ausgabe:

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

Mehrdimensionale Arrays in ein Objekt. Dieser Code wird für die Konvertierung der Try-Catch-Methode der Bing-Such-API verwendet.

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

Durch die Verwendung von (Array) und (Objekt) als Präfix können Sie das Objektarray einfach in ein Standardarray und umgekehrt konvertieren

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

Ich verwende Folgendes, um Yaml-Dateien assoziative Arrays in einen Objektstatus zu parsen.

Dadurch werden alle gelieferten Arrays überprüft, ob sich dort Objekte versteckt haben, und werden auch in Objekten umgewandelt.

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

Dadurch wird ein yaml als konfiguriert

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

zu einem Array bestehend aus:

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

zu einem Objekt von:

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

Sie können Reflection verwenden:

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

ich habe es auf ganz einfache Weise gemacht, 

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

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