PHP में ऑब्जेक्ट को कैसे कन्वर्ट करें?

Question

मैं इस तरह की एक सरणी को ऑब्जेक्ट में कैसे बदल सकता हूं?

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

Comments

आप किस प्रकार की वस्तु प्राप्त करना चाहते हैं, ठीक है? मेरा मतलब है: क्या विशेषताएं होनी चाहिए?

— पास्कल मार्टिन 18

एक लूप में यह दोनों होना चाहिए क्योंकि स्टेटस एक डेटा ऐरे है इसलिए दोनों ही प्रिटेट हैं

— स्ट्रीटपरेड 19

कब से यकीन नहीं है, लेकिन यह सिर्फ काम करता है:$a = (object)['hello' => 'world'];

— निश्चल गौतम

Answer 1

सबसे सरल मामले में, यह संभवतः एक ऑब्जेक्ट के रूप में सरणी को "कास्ट" करने के लिए पर्याप्त है:

$object = (object) $array;

एक अन्य विकल्प एक मानक वर्ग को एक चर के रूप में त्वरित करना होगा, और मूल्यों को फिर से असाइन करते समय अपने सरणी के माध्यम से लूप होगा:

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

जैसा कि एडसन मदीना ने बताया, वास्तव में स्वच्छ समाधान अंतर्निहित json_कार्यों का उपयोग करना है:

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

यह भी (पुनरावर्ती) आपके सभी उप सरणियों को वस्तुओं में परिवर्तित करता है, जिसे आप चाहते हैं या नहीं कर सकते हैं। दुर्भाग्य से यह लूपिंग दृष्टिकोण पर एक 2-3x प्रदर्शन हिट है ।

चेतावनी! (टिप्पणी के लिए अल्ट्रा के लिए धन्यवाद):

विभिन्न एनवायरमेंट पर json_decode UTF-8 डेटा को अलग-अलग तरीकों से परिवर्तित करता है। मैं अंत में स्थानीय स्तर पर '240.00' और उत्पादन पर '240' मूल्यों पर हो रहा है - बड़े पैमाने पर विघटन। यदि रूपांतरण विफल रहता है तो स्ट्रिंग को NULL के रूप में लौटाया जाता है

Comments

"चूंकि चर संख्याओं से शुरू नहीं हो सकते", हां वे कर सकते हैं: $ वस्तु -> {3} = 'xyz';

— chelmertz

"में 2-3x प्रदर्शन हिट होता है" जो एक अनुचित तुलना है, क्योंकि बाद वाली विधि पुनरावर्ती वस्तुओं को लौटाती है, जबकि आगे की स्थितियों के बिना लूपिंग दृष्टिकोण (@streetparade के उत्तर में) केवल पहले स्तर को परिवर्तित करता है।

— परेला

@feeela मुझे नहीं लगता कि यह बिल्कुल भी अनुचित है। मैंने उल्लेख किया है कि यह रूपांतरण को पुनरावृत्ति करता है। इसके अलावा, 2-3x प्रदर्शन हिट एक फ्लैट इनपुट सरणी (जो किसी भी पुनरावृत्ति का उपयोग नहीं करेगा) का उपयोग करने पर आया था

— jlb

चेतावनी! विभिन्न एनवायरमेंट पर json_decode UTF-8 डेटा को अलग-अलग तरीकों से परिवर्तित करता है। मैं अंत में स्थानीय स्तर पर '240.00' और उत्पादन पर '240' के मूल्यों को प्राप्त कर रहा हूं - बड़े पैमाने पर विघटन। यदि रूपांतरण विफल रहता है तो स्ट्रिंग स्ट्रिंग के रूप में NULL

— Szymon Toda

ध्यान दें कि json_ * फ़ंक्शन का उपयोग करते समय: मूल सरणी में संग्रहीत संदर्भ (जैसे अन्य सरणियों) को इस मामले में डुप्लिकेट किया जाएगा। कहो कि xसरणी में कुंजी दूसरे सरणी के लिए संदर्भ रखती है। फिर $object->xआपके वन-लाइनर के निष्पादन के बाद $array['x'], डुप्लिकेट हो जाएगा , मूल सरणी का कोई संदर्भ नहीं। यह कुछ अनुप्रयोगों में हानिरहित हो सकता है, लेकिन बड़े सरणियों के लिए यह मेमोरी बर्बाद करता है और निष्पादन को गड़बड़ कर सकता है यदि संदर्भ को बाद में उपयोग किया जा रहा है।

— कोपरोल

Answer 2

आप किसी ऑब्जेक्ट को ऑब्जेक्ट में बदलने के लिए बस टाइपिंग कास्टिंग का उपयोग कर सकते हैं।

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

Answer 3

आसान तरीका होगा

$object = (object)$array;

लेकिन वह नहीं है जो आप चाहते हैं। यदि आप चाहते हैं कि वस्तुओं को आप कुछ हासिल करना चाहते हैं, लेकिन वह इस प्रश्न में गायब है। केवल वस्तुओं के उपयोग के कारण वस्तुओं का उपयोग करने का कोई मतलब नहीं है।

Comments

काम नहीं करता है, मैंने इससे पहले कि मैं यहाँ सवाल पूछा था तो वहाँ करने के लिए एक और तरीका होना चाहिए

— Streetparade

वस्तुओं का उपयोग करने के लिए उसे अपना कारण क्यों देना पड़ता है? मुझे नहीं लगता कि यह कैसे किया जाता है के लिए प्रासंगिक है। शायद वह उन्हें json_encode करने की आवश्यकता है, या उन्हें अनुक्रमित करें? ऐसा करने के दर्जनों कारण हो सकते हैं।

— zombat

हम्म .. मैंने ब्राउज़र आउटपुट को देखा यह ऐसा लगता है कि यह ऑब्जेक्ट (stdClass) # 150 (130) {[0] => सरणी (1) {["स्थिति"] => स्ट्रिंग (130) "लंबे समय तक मैक और क्रोम भूमि में लिनक्स उपयोगकर्ताओं को द्वितीय श्रेणी के नागरिकों की तरह महसूस करने की आवश्यकता नहीं है: उन्हें आधिकारिक बीटा वर्सियो मिला है ... "} आधिकारिक यह एक वस्तु है लेकिन इसे कैसे फेंकना है, जिससे मैं $ obj जैसे स्थिति का आरोप लगा सकता हूं-> किसी भी विचार की स्थिति ?

— स्ट्रीटपेड 19

zombat, JSON एन्कोड किसी ऑब्जेक्ट का उपयोग करने का कोई कारण नहीं है, ऑब्जेक्ट का उपयोग करने के लिए json_encode () के लिए एक ध्वज है। क्रमबद्ध करने के साथ किसी एक को रिसीवर द्वारा अपेक्षित विशिष्ट ऑब्जेक्ट प्रकार की आवश्यकता होगी। और सामान्य तौर पर मैं वास्तविक समस्या के साथ मदद करने की कोशिश करता हूं । मेरे लिए यह प्रश्न स्पष्ट है कि कहीं और एक वास्तु दोष है।

— जोहान्स

एक अच्छा, वस्तु मुद्दे पर लार्वा सरणी के साथ काम

— एंथनी काल

Answer 4

त्वरित हैक:

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

सुंदर नहीं है, लेकिन काम करता है।

Comments

मैं वास्तव में इस समाधान को प्यार करता हूं, उपयोगकर्ता द्वारा परिभाषित कार्यों के बजाय अंतर्निहित कार्यों का उपयोग करना हमेशा तेज होता है, और यह बहुत अच्छा काम करता है। पारितोषिक के लिए धन्यवाद।

— एकनाट्न

@Oddant यह ऊपर बताई गई समस्या को हल करता है (एक सरणी को एक ऑब्जेक्ट में बदलें)। आपके शेख़ी को मुख्य पद में निर्देशित किया जाना चाहिए, न कि मेरे समाधान पर।

— एडसन मदीना

@EdsonMedina मैंने किया, मेरी पोस्ट वैसे भी बहुत नीचे है।

— vdegenne

@Oddant, @EdsonMedina के प्रति निष्पक्ष होने के लिए, मूल प्रश्न यह निर्दिष्ट नहीं करता है कि विशेषताओं को किस दृश्यता की आवश्यकता है, और चूंकि ओपी $thisउन टिप्पणियों में उपयोग नहीं करता है जो अनुवर्ती के रूप में अनुसरण करते हैं यह भारी रूप से निहित है, वह stdClassआउटपुट के लिए एक उदाहरण चाहती है / नहीं उपयोगकर्ता-परिभाषित वर्ग जैसे कि आपका उत्तर उपयोग करता है। मैं इस समाधान की लालित्य पर सहमत हूं, लेकिन दुर्भाग्य से यह एक सामान्य रूप से नियोजित पैटर्न है, इस समस्या को हल करने के लिए नेस्टेड सरणियों के साथ जहां ऑब्जेक्ट काम करना होगा। यह भी संभव है कि ओपी एक ऐसे इंटरफेस का उपयोग कर रहा है जिसके लिए इनपुट के रूप में ऑब्जेक्ट की आवश्यकता होती है न कि किसी ऐरे की।

— डेकोन्डेस्पेरैडो

मत भूलो कि इस तरह से उपयोग करने से आप सभी प्रकार के मूल प्रकार खो देंगे। दिनांक समय उदाहरण के लिए कनवर्टर stdObject होगा।

— डेनिस पशेनोव

Answer 5

यहाँ तीन तरीके हैं:

1. नकली एक वास्तविक वस्तु:

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

2. किसी ऑब्जेक्ट को ऑब्जेक्ट में डालकर ऐरे को ऑब्जेक्ट में कन्वर्ट करें:

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

3. सरणी को ऑब्जेक्ट में मैन्युअल रूप से कनवर्ट करें:

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

Comments

हम्म धन्यवाद लेकिन अपने चेहरे वर्ग निम्न त्रुटि गंभीर त्रुटि देता है: पर लाइन 10 को पुन: असाइन नहीं कर सकते /var/www/bot/inc/twitter-bot.php में $ इस

— streetparade

और टाइपकास्टिन @ संदर्भ एक अच्छा विचार नहीं है, यहां तक ​​कि यह काम नहीं करेगा यहां मुझे अप्रत्याशित T_OBJECT_CAST मिला है, जो T_NEW या T_STRING या T_VARIABLE या '$' की

— अपेक्षा करता है

$ सरणी = & (वस्तु) $ सरणी == अच्छा KISS कार्यान्वयन!

— mate64 16

कोई भी 2 से भिन्न विधि का उपयोग क्यों करना चाहेगा)? क्या कोई डाउनसाइड है?

— योगू

नेस्टेड

— एरेट्स

Answer 6

इसका सरल तरीका है, यह पुनरावर्ती सरणियों के लिए एक वस्तु का निर्माण करेगा:

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

Comments

गुजर falseके लिए json_decode()एक साहचर्य सरणी वापस आ जाएगी।

— जंग

@ user3284463 एक सहयोगी सरणी वापस trueकरने के लिए पासिंग json_decode, falseडिफ़ॉल्ट है और एक StdClassउदाहरण लौटाएगा ।

— इलियट रीड

Answer 7

इस बात पर निर्भर करता है कि आपको कहां क्या चाहिए और ऑब्जेक्ट को कैसे एक्सेस करना है, इसे करने के अलग-अलग तरीके हैं।

उदाहरण के लिए: बस इसे टाइप करें

$object =  (object) $yourArray;

हालांकि, सबसे अधिक संगत एक उपयोगिता विधि (PHP का हिस्सा नहीं है) का उपयोग कर रहा है जो मानक स्ट्रिंग पर आधारित PHP कास्टिंग को लागू करता है जो प्रकार को निर्दिष्ट करता है (या मूल्य को अनदेखा करते हुए):

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

आपके मामले में उपयोग का उदाहरण ( ऑनलाइन डेमो ):

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

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

Answer 8

यह एक मेरे लिए काम किया

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

उपयोग:

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

रिटर्न:

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

हमेशा की तरह आप इसे पसंद कर सकते हैं:

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

Comments

लेकिन यह एक प्रकार की कास्टिंग की तुलना में लगभग 500% धीमा (परीक्षण) है: $ obj = (ऑब्जेक्ट) $ सरणी;

— xZero

@ xZero लेकिन $obj = (object) $array;बहुआयामी सरणियों के लिए काम नहीं करता है।

— जेफ पकेट

Answer 9

जहां तक ​​मुझे पता है, इसे करने के लिए कोई अंतर्निहित पद्धति नहीं है, लेकिन यह एक साधारण लूप जितना आसान है:

    $obj= new stdClass();

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

आप उस पर विस्तार कर सकते हैं यदि आपको अपनी वस्तु को फिर से बनाने के लिए इसकी आवश्यकता है।

Answer 10

आप अपने एरे को ऑब्जेक्ट में बदलने के लिए (ऑब्जेक्ट) फ़ंक्शन का उपयोग कर सकते हैं।

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

परिणाम एक ऐसी वस्तु होगी जिसमें सरणियाँ शामिल हैं:

ऑब्जेक्ट (stdClass) # 1048 (2) {[128] => सरणी (1) {

["स्थिति"] => स्ट्रिंग (87) "चित्र ए। फेसबुक के क्षैतिज स्क्रॉलबार एक 1024x768 मिलियन रिज़ॉल्यूशन पर दिखाई दे रहे हैं।" }

[१२ ९] => सरणी (१) {["स्थिति"] => स्ट्रिंग (४४) "काम पर दूसरे दिन, मेरे पास कुछ खाली समय था"}}

Answer 11

वास्तव में यदि आप इसे बहुआयामी सरणियों के साथ उपयोग करना चाहते हैं तो आप कुछ पुनरावृत्ति का उपयोग करना चाहेंगे।

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

Answer 12

मैं निश्चित रूप से इस तरह से एक स्वच्छ तरीके से जाऊंगा:

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

?>

यदि आप सबमिट करते हैं:

आपको यह मिलेगा:

मुझे यह अधिक तार्किक लगा कि वस्तुओं के उपर्युक्त उत्तरों की तुलना उस उद्देश्य के लिए की जानी चाहिए जिसका वे उपयोग किया गया है (प्यारा छोटी वस्तुओं को एनकैप्सुलेटेड)।

इसके अलावा get_object_vars का उपयोग यह सुनिश्चित करता है कि हेरफेर किए गए ऑब्जेक्ट में कोई अतिरिक्त विशेषता नहीं बनाई गई है (आप एक परिवार के नाम वाली कार नहीं चाहते हैं, न ही 4 पहियों का व्यवहार करने वाला व्यक्ति)।

Comments

आप $ array [$ attr_name] के बजाय $ attr_value का उपयोग क्यों नहीं करते; in_array ($ सरणी) फ़ंक्शन से अपने

— रिपब्लिक

Answer 13

आप एक ArrayObject का उपयोग भी कर सकते हैं, उदाहरण के लिए:

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

Comments

मेरी राय में यह सबसे अच्छा जवाब बन जाना चाहिए। अधिक जानकारी herre: php.net/manual/en/arrayobject.construct.php

— जूलियन

Answer 14

जो मैं उपयोग करता हूं (यह एक वर्ग सदस्य है):

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

Answer 15

तकनीक का विस्तार करने के लिए थोड़ा जटिल लेकिन आसान:

मान लीजिए कि आपके पास एक सरणी है

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

मान लीजिए कि आपके पास एक व्यक्ति वर्ग है, जिसके पास इस सरणी से अधिक या कम विशेषताएँ हो सकती हैं। उदाहरण के लिए

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

यदि आप अभी भी अपने ऑब्जेक्ट को व्यक्ति ऑब्जेक्ट में बदलना चाहते हैं। आप ArrayIterator Class का उपयोग कर सकते हैं।

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

अब आपके पास itter ऑब्जेक्ट है।

FilterIterator क्लास का विस्तार करने वाला एक वर्ग बनाएं; जहाँ आपको अमूर्त पद्धति को परिभाषित करना होगा। उदाहरण का अनुसरण करें

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

उपरोक्त अयोग्यता संपत्ति को केवल तभी बाँधेंगी जब वह कक्षा में मौजूद हो।

क्लास पर्सनलेटर में एक और विधि जोड़ें

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

सुनिश्चित करें कि आपके पास अपनी कक्षा में परिभाषित म्यूटेटर हैं। अब आप इन फ़ंक्शन को कॉल करने के लिए तैयार हैं जहां आप ऑब्जेक्ट बनाना चाहते हैं।

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

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

Answer 16

पुनरावृत्ति आपका मित्र है:

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

    return $obj;
}

Answer 17

इसके लिए PHP7 की आवश्यकता होती है क्योंकि मैंने मुख्य कार्य के भीतर 'इनरफूनक' को बंद करने के लिए एक लैम्ब्डा फ़ंक्शन का उपयोग करने के लिए चुना था। लैम्ब्डा फ़ंक्शन को पुनरावर्ती कहा जाता है, इसलिए इसकी आवश्यकता है: "उपयोग (और $ इनरफूनक)"। आप इसे PHP5 में कर सकते हैं लेकिन इनरफून को छिपा नहीं सकते।

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

Answer 18

इस फ़ंक्शन का उपयोग करें जो मैंने बनाया है:

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

उपयोग:

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

Answer 19

एक लाइन

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

Comments

ध्यान दें कि मूल सरणी में संग्रहीत संदर्भ (जैसे अन्य सरणियों) को इस एक-लाइनर द्वारा दोहराया जाएगा। कहो कि xसरणी में कुंजी दूसरे सरणी के लिए संदर्भ रखती है। फिर $object->xआपके वन-लाइनर के निष्पादन के बाद डुप्लिकेट हो जाएगा $result_array['x'], समान सरणी नहीं।

— कोपरल

Answer 20

आसान:

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

उदाहरण:

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

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

फिर, निम्नलिखित सत्य है:

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

Comments

मुझे लगता है कि यह एक वर्कअराउंड है। एक सरणी को json में क्यों एनकोड करें और फिर उसे डिकोड करें? यह मेरे लिए एक इष्टतम निर्णय नहीं है।

— जूलियन

@ जूलियन, क्योंकि यह पुनरावर्ती रूप से काम करता है, इसे ठीक से परिभाषित और पर्याप्त रूप से विश्वसनीय ("मानक") तरीके से करता है, और यह तेजी से यादृच्छिक हाथ से कोडित बंदर जादू का एक अच्छा विकल्प होने के लिए पर्याप्त है।

— एस.जे.

Answer 21

आप एक नई वस्तु बनाने के लिए चर के बाईं ओर (ऑब्जेक्ट) जोड़कर भी ऐसा कर सकते हैं ।

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

http://codepad.org/9YmD1KsU

Comments

शायद लायक उल्लेख इस "कास्टिंग" या "प्रकार कास्टिंग" कहा जाता है कहा जाता है: php.net/manual/en/... और की (वस्तु) सरणी व्यवहार () यहाँ प्रलेखित है: php.net/manual/en/...

— पीट

Answer 22

का उपयोग करते हुए json_encode, क्योंकि जिस तरह से है कि यह गैर UTF-8 डेटा का प्रबंधन का समस्याग्रस्त है। यह ध्यान देने योग्य है कि json_encode/ json_encodeविधि गैर-सहयोगी सरणियों को सरणियों के रूप में भी छोड़ देती है। यह वही हो सकता है या नहीं हो सकता है जो आप चाहते हैं। मैं हाल ही में इस समाधान की कार्यक्षमता को फिर से बनाने की आवश्यकता की स्थिति में था लेकिन json_कार्यों का उपयोग किए बिना । यहाँ मैं क्या लेकर आया हूँ:

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

Answer 23

दुनिया में सबसे अच्छा तरीका :)

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

यदि आप विभिन्न तरीकों का उपयोग करते हैं तो आपको समस्याएं होंगी। यह सबसे अच्छी विधि है। तुमने कभी देखा है।

Answer 24

एक वस्तु में बहुआयामी सरणियाँ। इस कोड का उपयोग बिंग सर्च एपीआई ट्राइ और कैच मेथड के रूपांतरण के लिए किया जाता है।

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

Answer 25

आप प्रतिबिंब का उपयोग कर सकते हैं:

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

Answer 26

CakePHP में एक पुनरावर्ती सेट :: मानचित्र वर्ग है जो मूल रूप से किसी ऑब्जेक्ट में एक सरणी को मैप करता है। आपको ऑब्जेक्ट को जिस तरह से आप चाहते हैं, उसे देखने के लिए सरणी को कैसा दिखता है, इसे बदलने की आवश्यकता हो सकती है।

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

सबसे खराब स्थिति, आप इस फ़ंक्शन से कुछ विचार प्राप्त करने में सक्षम हो सकते हैं।

Answer 27

स्पष्ट रूप से कुछ अन्य लोगों के उत्तरों का सिर्फ एक एक्सट्रपलेशन है, लेकिन यहाँ पुनरावर्ती फ़ंक्शन है जो किसी भी गीले-आयामी सरणी को ऑब्जेक्ट में बदल देगा:

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

और याद रखें कि सरणी का उपयोग करके संख्यात्मक कुंजियों वे अभी भी है, जिसके परिणामस्वरूप वस्तु में संदर्भित किया जा सकता था अगर {}(उदाहरण के लिए: $obj->prop->{4}->prop)

Answer 28

इन सभी संहिताओं से प्रेरित होकर, मैंने समर्थन के साथ एक उन्नत संस्करण बनाने की कोशिश की: विशिष्ट वर्ग का नाम, निर्माता विधि से बचें, 'सेम' पैटर्न और सख्त मोड (केवल मौजूदा गुण सेट करें):

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

Answer 29

कोड

यह फंक्शन उतना ही काम करता है 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;
}

परिक्षण

परीक्षण 1: सपाट सरणी

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

आउटपुट:

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

परीक्षण 2: वस्तुओं का सरणी

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

आउटपुट:

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

टेस्ट 3: वस्तु

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

आउटपुट:

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

Answer 30

मैंने इसे बहुत सरल तरीके से किया है,

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

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