Böyle bir diziyi nesneye nasıl dönüştürebilirim?

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

En basit durumda, diziyi bir nesne olarak "yayınlamak" muhtemelen yeterlidir:

$object = (object) $array;

Başka bir seçenek, standart sınıfı değişken olarak başlatmak ve değerleri yeniden atarken diziniz arasında döngü yapmaktır:

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

Edson Medina'nın belirttiği gibi , gerçekten temiz bir çözüm yerleşik json_işlevleri kullanmaktır:

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

Bu ayrıca (yinelemeli olarak) tüm alt dizilerinizi isteyebileceğiniz veya istemeyeceğiniz nesnelere dönüştürür. Ne yazık ki , döngü yaklaşımı üzerinde 2-3 kat bir performans isabeti var.

Uyarı! (yorum için Ultra'ya teşekkürler):

Farklı ortamlardaki json_decode, UTF-8 verilerini farklı şekillerde dönüştürür. Sonunda yerel olarak '240.00' ve üretimde '240' değerlerine ulaşıyorum - büyük çaplı dissaster. Dönüşüm dize başarısız olursa morover get NULL olarak döndürülür

bir diziyi nesneye dönüştürmek için tür dökümünü kullanabilirsiniz.

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

Kolay yol

$object = (object)$array;

Ama istediğin bu değil. Nesneler istiyorsanız, bir şey elde etmek istiyorsunuz, ancak bu soruda bu eksik. Nesneleri yalnızca nesne kullanma nedeni ile kullanmak mantıklı değildir.

Hızlı kesmek:

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

Güzel değil, ama çalışıyor.

İşte üç yol:

1. Sahte gerçek bir nesne:

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

2. Diziyi bir nesneye çevirerek nesneye dönüştürün:

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

3. Diziyi manuel olarak bir nesneye dönüştürün:

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

Basit yolu, Yinelemeli diziler için de bir nesne oluşturur:

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

Buna ihtiyacınız olan yere ve nesneye nasıl erişeceğinize bağlı olarak, bunu yapmanın farklı yolları vardır.

Örneğin: sadece yazın

$object =  (object) $yourArray;

Bununla birlikte, en uyumlu olanı, türü belirten bir dizeye dayalı olarak standart PHP dökümünü uygulayan bir yardımcı yöntem (henüz PHP'nin bir parçası değil) kullanmaktır (veya yalnızca değeri referans alarak yok sayarak):

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

Sizin durumunuzdaki kullanım örneği ( Çevrimiçi Demo ):

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

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

Bu benim için çalıştı

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

kullanım:

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

İadeler :

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

her zamanki gibi döngü yapabilirsiniz:

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

Bunu bildiğim kadarıyla yapmak için yerleşik bir yöntem yok, ancak basit bir döngü kadar kolay:

    $obj= new stdClass();

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

Nesnenizi özyinelemeli olarak oluşturmanız gerekiyorsa buna açıklayabilirsiniz.

Dizinizi bir nesneye dönüştürmek için (object) işlevini kullanabilirsiniz.

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

Sonuç diziler içeren bir nesne olacaktır:

nesne (stdClass) # 1048 (2) {[128] => dizi (1) {

["status"] => string (87) "Şekil A. 1024x768 ekran çözünürlüğünde görünen Facebook'un yatay kaydırma çubukları." }

[129] => dizi (1) {["status"] => string (44) "Geçen gün işte boş vaktim vardı"}}

Aslında bunu çok boyutlu dizilerle kullanmak istiyorsanız, tekrarlama kullanmak istersiniz.

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

Kesinlikle böyle temiz bir yolla gitmek istiyorum:

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

?>

eğer gönderirseniz:

bunu alacaksınız:

Bu daha mantıklı buldum Nesnelerin yukarıdaki cevapları için yapıldıkları amaç için kullanılmalıdır (kapsüllenmiş sevimli küçük nesneler).

Ayrıca get_object_vars komutunu kullanmak, manipüle edilen Nesne'de ekstra özellik oluşturulmamasını sağlar (soyadı olan bir arabanın veya 4 tekerlekli davranan bir kişinin olmasını istemezsiniz).

Bir ArrayObject de kullanabilirsiniz, örneğin:

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

Kullandığım (bir sınıf üyesi):

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

Az karmaşık ancak genişletilmesi kolay teknik:

Bir diziniz olduğunu varsayalım

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

Bu diziden daha fazla veya daha az özniteliği olabilecek bir Person sınıfınız olduğunu varsayalım. Örneğin

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

Dizinizi hala kişi nesnesine değiştirmek istiyorsanız. ArrayIterator Sınıfını kullanabilirsiniz.

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

Şimdi yineleyici nesneniz var.

FilterIterator Sınıfını genişleten bir sınıf oluşturun; Burada soyut yöntemi tanımlamanız gerekir kabul. Örneği takip edin

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

Yukarıdaki impelmentation özelliği yalnızca sınıfta varsa bağlar.

PersonIterator sınıfına bir yöntem daha ekleyin

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

Sınıfınızda tanımlı mutatör bulunduğundan emin olun. Artık nesne oluşturmak istediğiniz bu işlevi çağırmaya hazırsınız.

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

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

özyineleme senin arkadaşın:

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

    return $obj;
}

Ana işlevi içinde 'innerfunc' kilitlemek için bir lambda işlevi kullanmayı seçti çünkü bu PHP7 gerektirir. Lambda işlevi özyinelemeli olarak adlandırılır, bu nedenle şunlara ihtiyaç vardır: "use (& $ innerfunc)". PHP5 ile yapabilirsiniz ama innerfunc gizlemek olamazdı.

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

yaptığım bu işlevi kullanın:

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

Kullanımı:

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

bir astar

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

Kolay:

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

Misal:

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

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

Sonra, aşağıdakiler doğrudur:

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

Bunu, yeni bir nesne oluşturmak için değişkenin soluna (nesne) ekleyerek de yapabilirsiniz .

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

http://codepad.org/9YmD1KsU

json_encodeUTF-8 olmayan verileri işleme biçimi nedeniyle kullanmak sorunludur. json_encode/ json_encodeYönteminin ilişkisel olmayan dizileri de diziler olarak bıraktığını belirtmek gerekir . İstediğiniz şey bu olabilir veya olmayabilir. Kısa bir süre önce bu çözümün işlevselliğini yeniden yaratmaya ihtiyaç duyduğum halde, işlevleri kullanmadan konumdaydım json_. İşte ben geldim:

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

DÜNYANIN EN İYİ YOLU :)

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

farklı yöntemler kullanırsanız sorunlarınız olacaktır. Bu en iyi yöntemdir. Hiç gördün mü.

Bir nesneye çok boyutlu diziler. bu kod Bing arama API'sı try ve catch yönteminin dönüştürülmesi için kullanılır.

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

Yansıma'yı kullanabilirsiniz:

<?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, bir diziyi temel olarak bir nesneye eşleyen özyinelemeli bir Set :: map sınıfına sahiptir. Nesnenin istediğiniz gibi görünmesini sağlamak için dizinin neye benzediğini değiştirmeniz gerekebilir.

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

En kötü durumda, bu işlevden birkaç fikir edinebilirsiniz.

Açıkçası sadece diğer insanların cevaplarının bir ekstrapolasyonu, ancak herhangi bir malç boyutlu diziyi bir nesneye dönüştürecek özyinelemeli fonksiyon:

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

Ve unutmayın dizi kullanarak hala elde edilen nesne başvurulabilir sayısal tuşları olsaydı {}(örneğin: $obj->prop->{4}->prop)

Tüm bu kodlardan esinlenerek, aşağıdakileri destekleyen gelişmiş bir sürüm oluşturmaya çalıştım: belirli sınıf adı, yapıcı yöntemi, 'fasulye' deseni ve katı moddan kaçının (sadece mevcut özellikleri ayarlayın):

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

kod

Bu işlev ile aynı şekilde çalışır 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;
}

Test yapmak

Test 1: Düz dizi

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

Çıktı:

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

Test 2: Nesnelerin dizisi

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

Çıktı:

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

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

Çıktı:

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

oldukça basit bir şekilde yaptım,

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

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