Wie kann ich ein solches Array in ein Objekt konvertieren?

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

Im einfachsten Fall reicht es wahrscheinlich aus, das Array als Objekt zu "gießen":

$object = (object) $array;

Eine andere Möglichkeit wäre, eine Standardklasse als Variable zu instanziieren und Ihr Array zu durchlaufen, während Sie die Werte neu zuweisen:

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

Wie Edson Medina betonte, besteht eine wirklich saubere Lösung darin, die integrierten json_Funktionen zu verwenden:

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

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

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

json_decode konvertiert UTF-8-Daten in verschiedenen Umgebungen auf unterschiedliche Weise. Am Ende habe ich die Werte '240,00' vor Ort und '240' in der Produktion erreicht - massive Katastrophe. Wenn die Konvertierung fehlschlägt, wird der String als NULL zurückgegeben

Sie können einfach Typ Casting verwenden, um ein Array in ein Objekt zu 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;

Der einfache Weg wäre

$object = (object)$array;

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

Schneller Hack:

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

Nicht schön, funktioniert aber.

Hier sind drei Möglichkeiten:

1. Ein echtes Objekt vortäuschen:

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

Es wird zu einfach. Dadurch wird auch ein Objekt für rekursive Arrays erstellt:

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

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

Zum Beispiel: Geben Sie es einfach ein

$object =  (object) $yourArray;

Am kompatibelsten ist jedoch die Verwendung einer Dienstprogrammmethode (die noch nicht Teil von PHP ist), die Standard-PHP-Casting basierend auf einer Zeichenfolge implementiert, die den Typ angibt (oder indem sie ignoriert wird, indem nur der Wert de-referenziert 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. ..."

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 können Sie es wie folgt schleifen:

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

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.

Mit der Funktion (Objekt) 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:

Objekt (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) "Neulich bei der Arbeit hatte ich etwas Freizeit"}}

Wenn Sie dies mit mehrdimensionalen Arrays verwenden möchten, sollten 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;
}

Ich würde definitiv einen sauberen Weg wie diesen 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 Sie einreichen:

Sie werden dies bekommen:

Ich fand es logischer, die obigen Antworten von Objekten zu vergleichen, um sie für den Zweck zu verwenden, für den sie gemacht wurden (eingekapselte süße kleine Objekte).

Durch die Verwendung von get_object_vars wird außerdem sichergestellt, dass im manipulierten Objekt keine zusätzlichen Attribute erstellt werden (Sie möchten weder ein Auto mit einem Familiennamen noch eine Person mit 4 Rädern).

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

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

Wenig komplizierte aber leicht zu erweiternde Technik:

Angenommen, Sie haben ein Array

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

Angenommen, Sie haben eine Personenklasse, die möglicherweise mehr oder weniger Attribute aus diesem Array enthält. zum Beispiel

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

Wenn Sie Ihr Array dennoch in das Personenobjekt ändern möchten. Sie können die 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 müssen Sie die abstrakte Methode akzeptieren definieren. Folge dem Beispiel

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

Die obige Impelmentation bindet die Eigenschaft nur, wenn sie in der Klasse vorhanden ist.

Fügen Sie der Klasse PersonIterator eine weitere Methode 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. Jetzt können Sie diese Funktion aufrufen, in der Sie ein Objekt erstellen möchten.

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

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

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

Dies erfordert PHP7, da ich mich für die Verwendung einer Lambda-Funktion entschieden habe, um die 'innere Funktion' innerhalb der Hauptfunktion zu sperren. Die Lambda-Funktion wird rekursiv aufgerufen, daher ist Folgendes erforderlich: "use (& $ innerfunc)". Sie könnten es in PHP5 tun, aber die innere Funktion nicht verbergen.

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

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

Einzeiler

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

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 ist folgendes wahr:

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

Sie können dies auch tun, indem Sie links von der Variablen (Objekt) 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

Die Verwendung json_encodeist problematisch, da nicht UTF-8-Daten verarbeitet werden. Es ist erwähnenswert, dass die json_encode/ json_encode-Methode auch nicht assoziative Arrays als Arrays belässt. Dies kann sein oder nicht, was Sie wollen. Ich war kürzlich in der Lage, die Funktionalität dieser Lösung neu zu erstellen, ohne jedoch 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;
    }
}

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 verschiedene Methoden verwenden, treten Probleme auf. Dies ist die beste Methode. Hast du jemals gesehen.

Mehrdimensionale Arrays in ein Objekt. Dieser Code wird für die Konvertierung der Try-and-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);
    }

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

CakePHP verfügt über eine rekursive Set :: map-Klasse, die ein Array grundsätzlich einem Objekt zuordnet. Möglicherweise müssen Sie 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 möglicherweise einige Ideen aus dieser Funktion gewinnen.

Natürlich nur eine Extrapolation der Antworten einiger anderer Leute, aber hier ist die rekursive Funktion, die jedes mulchdimensionale Array in ein Objekt umwandelt:

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

Und denken Sie daran , dass , wenn das Array numerische Tasten hat sie noch in dem resultierenden Objekt referenziert wird unter Verwendung {}(zB: $obj->prop->{4}->prop)

Inspiriert von all diesen Codes habe ich versucht, eine erweiterte Version zu erstellen, die Folgendes unterstützt: spezifischen Klassennamen, Konstruktormethode, 'Beans'-Muster und strengen Modus vermeiden (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;
        }
        }
}

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

Ich habe es auf ganz einfache Weise getan.

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

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