दिलचस्प पोस्ट
PHP में एकाधिक वंशानुक्रम एक सूची में data.frame पंक्तियां JQuery का डॉलर ASP.Net MVC में StringTemplate.Net के साथ संघर्ष में है JAX-RS एप्लिकेशन को केवल एनोटेशन का उपयोग कैसे करें (कोई web.xml) नहीं है? तैयार स्थिति सेटनल (..) विम के साथ आपका सबसे उत्पादक शॉर्टकट क्या है? जावा में JButton पर फिट करने के लिए आइकन का आकार बदलना है? एंड्रॉइडः स्ट्रिंग के पिछले 3 अक्षों को स्वचालित रूप से छांटकर स्थानांतरित करें स्ट्रिंग को द्विआधारी में अजगर में कनवर्ट करें कंस्ट्रक्टर में फ़ील्ड प्रारंभ करना – प्रारंभिक सूची बनाम निर्माता सामग्री दृश्य सी ++ का उपयोग करके कोड के पीछे असेंबली को कैसे देखें? । htaccess: अमान्य कमांड 'रीवरइटइंजिन', संभवतः गलत वर्तनी या परिभाषित किया गया एक मॉड्यूल जो सर्वर कॉन्फ़िगरेशन में शामिल नहीं है मैं जावास्क्रिप्ट में एक गतिशील रूप से नामित विधि कैसे कॉल करूं? 2 क्षेत्रों की तुलना करने के लिए MongoDb क्वेरी स्थिति UIButton: चुने हुए हाइलाइट स्थिति के लिए छवि सेट करें

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

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

     [128] => सरणी
         (
             [स्थिति] => चित्रा ए
  फेसबुक की क्षैतिज स्क्रॉलबार एक 1024x768 स्क्रीन रिज़ोल्यूशन पर प्रदर्शित होते हैं
         )

     [12 9] => सरणी
         (
             [स्थिति] => दूसरे दिन काम पर, मेरे पास कुछ खाली समय था
         )

 )

वेब के समाधान से एकत्रित समाधान "PHP में ऑब्जेक्ट को ऑरेट करने के लिए कैसे करें?"

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

 $object = (object) $array; 

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

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

जैसा कि एडसन मदीना ने बताया, बिल्ट-इन json_ फ़ंक्शंस का उपयोग करने के लिए वास्तव में एक साफ समाधान है:

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

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

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

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

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

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

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

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

त्वरित हैक:

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

अच्छा नहीं है, लेकिन काम करता है

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

 $object = (object)$array; 

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

आप की आवश्यकता के आधार पर और ऑब्जेक्ट कैसे एक्सेस करना है यह करने के लिए अलग-अलग तरीके हैं।

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

 $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. ..." 

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

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

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

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

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

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

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

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

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

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

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

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

formulaire

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

माइक

मुझे यह पता चला है कि ऑब्जेक्ट्स से उपरोक्त उत्तरों की तुलना में यह अधिक तर्कसंगत प्रयोग किया जाना चाहिए (इनक्यूबेटेड प्यारा सा ऑब्जेक्ट्स)।

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

पुनरुत्थान आपका दोस्त है:

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

आसान:

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

आप एक 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 

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

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

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

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

http://codepad.org/9YmD1KsU

json_encode का उपयोग करना समस्या 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; } } 

विश्व में सर्वश्रेष्ठ विधि 🙂

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

यदि आप विभिन्न तरीकों का इस्तेमाल करते हैं तो आपको समस्याएं आती हैं यह सबसे अच्छा तरीका है आपने कभी देखा है

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

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

कोड

यह फ़ंक्शन 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,)) 

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

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

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

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

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

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

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

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

एक क्लायंट फ़िल्टरइटरेटर क्लास का विस्तार करें; जहां आपको अमूर्त पद्धति को परिभाषित करना होगा। उदाहरण का अनुसरण करें

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

उपरोक्त छेड़छाड़ केवल संपत्ति में बाँध रखेगा यदि वह कक्षा में मौजूद हो।

कक्षा PersonIterator में एक और विधि जोड़ें

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

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

 $arrayiterator = new \ArrayIterator($a); $personIterator = new \PersonIterator($arrayiterator); $personIterator->getObject(); // this will return your Person Object. 

एक लाइन

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

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

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

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

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

  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 )

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

  $list_years = array(); $object = new stdClass(); $object->year_id = 1 ; $object->year_name = 2001 ; $list_years[] = $object; 
 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; } 

(एरे) और (ऑब्जेक्ट) का इस्तेमाल करके उपसर्ग के रूप में, आप ऑब्जेक्ट सरणी को मानक सरणी और उपा-कविता में परिवर्तित कर सकते हैं

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

मैं निम्नलिखित का उपयोग करने के लिए एक ऑब्जेक्ट स्थिति में यौल्म फ़ाइलें साहचर्य सरणियों को पार्स करने के लिए

यह सभी आपूर्ति की गई arrays की जांच करता है, अगर वहां वस्तुओं को छुपा रहा है, और उन्हें ऑब्जेक्ट में भी बदल देता है।

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

यह एक yaml के रूप में कॉन्फ़िगर करता है

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

जिसमें सरणी शामिल है:

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

के उद्देश्य के लिए:

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

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