पीएचपी में काम करने की जटिलताओं

दिलचस्प PHP लिंक के हाल के डाइजेस्ट में , मुझे निकिता पोपोव की स्टैकऑवरफ़्लो पर टिप्पणी का लिंक मिला, जहां वह फ़ॉरचेक कंट्रोल संरचना के "हुड के तहत" तंत्र के बारे में विस्तार से बात करता है।
चूंकि कभी-कभी विचित्र अजीब तरीकों से अधिक काम करता है, इसलिए मुझे इस उत्तर का अनुवाद करने में मदद मिली।

ध्यान दें: इस पाठ का तात्पर्य PHP में zval'ov की कार्यक्षमता के बारे में बुनियादी ज्ञान की उपस्थिति से है, विशेष रूप से, आपको पता होना चाहिए कि क्या refcount और is_ref हैं।
foreach विभिन्न प्रकारों की संस्थाओं के साथ काम करता है: सरणियों के साथ, साधारण वस्तुओं (जहां उपलब्ध गुण सूचीबद्ध होते हैं) के साथ और ट्रैवर्सेबल ऑब्जेक्ट्स के साथ (या बल्कि, ऑब्जेक्ट जो आंतरिक get_iterator परिभाषित होते हैं)। यहां हम मुख्य रूप से सरणियों के बारे में बात कर रहे हैं, लेकिन मैं बाकी के बारे में बहुत अंत में बात करूंगा।

शुरू करने से पहले, संदर्भ को समझने के लिए महत्वपूर्ण सरणियों और उनके ट्रैवर्सल के बारे में कुछ शब्द।

कैसे सरणी ट्रैवर्सल काम करता है

PHP में Arrays को हैश टेबल का आदेश दिया गया है (हैश तत्वों को एक दोहरी लिंक की गई सूची में जोड़ा गया है) और निर्दिष्ट आदेश का पालन करते हुए सरणी के लिए आड़ू निकालता है।

PHP में किसी सरणी को पार करने के दो तरीके शामिल हैं:

• पहला तरीका एक आंतरिक सरणी सूचक है। यह पॉइंटर हैशटेबल स्ट्रक्चर का हिस्सा है और हैश टेबल में करंट आइटम का पॉइंटर है। आंतरिक सरणी सूचक को अशुद्धता के साथ बदला जा सकता है, अर्थात, यदि वर्तमान तत्व हटा दिया जाता है, तो आंतरिक सरणी सूचक को अगले में ले जाया जाएगा।
• दूसरा पुनरावृत्ति तंत्र एक बाहरी सरणी पॉइंटर है, जिसे हैशपोज़न कहा जाता है। यह लगभग सरणी के आंतरिक पॉइंटर के समान है, लेकिन यह हैशटेबल का हिस्सा नहीं है। यह बाहरी पुनरावृत्ति विधि परिवर्तन के लिए सुरक्षित नहीं है। यदि आप उस आइटम को हटाते हैं जिसे HashPosition इंगित करता है, तो आप झूलने वाले सूचक के साथ बने रहेंगे, जिससे विभाजन त्रुटि हो जाएगी।

इस प्रकार, बाहरी सरणी पॉइंटर्स का उपयोग केवल तब किया जा सकता है जब आप पूरी तरह से सुनिश्चित हों कि कोई कस्टम कोड निष्पादित नहीं किया जाएगा। और ऐसा कोड सबसे अप्रत्याशित जगह में हो सकता है, जैसे कि त्रुटि हैंडलर या डिस्ट्रक्टर। यही कारण है कि ज्यादातर मामलों में, PHP को बाहरी के बजाय एक आंतरिक सूचक का उपयोग करना पड़ता है। यदि यह अन्यथा थे, तो जैसे ही उपयोगकर्ता कुछ असामान्य करना शुरू करता है, PHP एक विभाजन दोष के कारण गिर सकता है।

आंतरिक पॉइंटर के साथ समस्या यह है कि यह एक हैशटेबल का हिस्सा है। इसलिए जब आप इसे बदलते हैं, तो इसके साथ हैशटेबल बदल जाता है। और चूंकि PHP में सरणियों का उपयोग मूल्य द्वारा किया जाता है (और संदर्भ द्वारा नहीं), तो आप लूप में इसके तत्वों को बायपास करने के लिए सरणी को कॉपी करने के लिए मजबूर हैं।

प्रतिलिपि बनाने के महत्व को दर्शाने वाला एक सरल उदाहरण (वैसे, यह बहुत दुर्लभ नहीं है), यह एक नेस्टेड पुनरावृत्ति है:

foreach ($array as $a) { foreach ($array as $b) { // ... } } 

यहाँ आप दोनों छोरों को स्वतंत्र होना चाहते हैं, न कि किसी एकल सूचक द्वारा छल किया जाना।

इसलिए, हम आगे निकल गए।

फॉरेक्स में ऐरे ट्रेवल

अब आप जानते हैं कि फोरचेक को चारों ओर जाने से पहले सरणी की एक प्रति क्यों बनानी होगी। लेकिन यह स्पष्ट रूप से पूरी कहानी नहीं है। क्या PHP एक प्रति बनाएगा या नहीं यह कई कारकों पर निर्भर करता है:

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

   $ref =& $array; // $array has is_ref=1 now foreach ($array as $val) { // ... } 

  
  क्यों? क्योंकि सरणी में कोई भी परिवर्तन आंतरिक सूचक सहित संदर्भ द्वारा प्रचारित होना चाहिए। यदि इस मामले में foreach ने प्रतिलिपि बनाई, तो यह लिंक के शब्दार्थ को नष्ट कर देगा।
• यदि सरणी में refcount = 1 है, तो प्रतिलिपि फिर से विफल हो जाएगी। refcount = 1 का अर्थ है कि सरणी का उपयोग कहीं और नहीं किया गया है और foreach इसे सीधे उपयोग कर सकते हैं। यदि प्रतिक्षेप एक से अधिक है, तो सरणी को अन्य चर के साथ विभाजित किया जाता है और परिवर्तन से बचने के लिए, फ़ॉरचेक को इसकी प्रतिलिपि बनाना चाहिए (ऊपर वर्णित लिंक के मामले की परवाह किए बिना)।
• यदि सरणी संदर्भित है (foreach ($ array as & $ ref)), तो - प्रतिलिपि या गैर-कॉपी फ़ंक्शन की परवाह किए बिना - सरणी एक लिंक बन जाएगा।

तो यह रहस्य का पहला हिस्सा है: प्रतिलिपि कार्य। दूसरा भाग यह है कि वर्तमान पुनरावृत्ति कैसे की जाती है, और यह भी अजीब है। "नियमित" पुनरावृत्ति पैटर्न जिसे आप पहले से जानते हैं (और जिसे अक्सर PHP में उपयोग किया जाता है - फ़ॉरच से अलग) कुछ इस तरह दिखता है (छद्म-कोड):

 reset(); while (get_current_data(&data) == SUCCESS) { code(); move_forward(); } 

फारसी पुनरावृत्ति थोड़ा अलग दिखता है:

 reset(); while (get_current_data(&data) == SUCCESS) { move_forward(); code(); } 

अंतर यह है कि Move_forward () को शुरुआत में निष्पादित किया जाता है, लूप के अंत में नहीं। इस प्रकार, जब उपयोगकर्ता कोड $ i का उपयोग करता है, तो सरणी का आंतरिक पॉइंटर पहले से ही $ i + 1 के तत्व को इंगित करता है।

फ़ॉरच के संचालन का यह तरीका भी यही कारण है कि यदि वर्तमान एक को हटा दिया जाए और पिछले एक को नहीं (जैसा कि आप उम्मीद कर सकते हैं) तो सरणी का आंतरिक पॉइंटर अगले तत्व पर चला जाता है। सब कुछ किया जाता है ताकि यह पूरी तरह से फॉर्च्यूनर के साथ काम करे (लेकिन, जाहिर है, बाकी सब कुछ इतनी अच्छी तरह से काम नहीं करेगा, तत्वों को लंघन)।

कोड प्रभाव

उपरोक्त व्यवहार का पहला परिणाम यह है कि foreach कई मामलों (धीरे) में एक पुनरावृत्ति सरणी की प्रतिलिपि बनाता है। लेकिन डर को अस्वीकार करें: मैंने प्रतिलिपि की आवश्यकता को हटाने की कोशिश की और कृत्रिम बेंचमार्क (जिसमें पुनरावृत्ति दुगनी तेजी से थी) को छोड़कर, कहीं भी काम के त्वरण को नहीं देख सका। ऐसा लगता है कि लोगों को बस यह पर्याप्त नहीं है।

दूसरा परिणाम यह है कि आमतौर पर कोई अन्य परिणाम नहीं होना चाहिए। फॉर्च्यूनर का व्यवहार मूल रूप से उपयोगकर्ता के लिए समझ में आता है और बस उसी रूप में काम करना चाहिए जैसा वह करना चाहिए। आपको इस बात की चिंता नहीं करनी चाहिए कि नकल कैसे होती है (और क्या ऐसा होता है), और समय पर किस विशेष बिंदु पर सूचक चलता है।

और तीसरा परिणाम - और यहाँ हम सिर्फ आपकी समस्याओं के करीब आ रहे हैं - वह यह है कि कभी-कभी हमें बहुत अजीब व्यवहार दिखाई देता है जिसे समझना मुश्किल है। यह विशेष रूप से तब होता है जब आप सरणी को स्वयं संशोधित करने का प्रयास करते हैं, जिसे आप लूप में बायपास करते हैं।

बॉर्डरलाइन मामलों में व्यवहार का एक बड़ा संग्रह जो तब दिखाई देता है जब आप पुनरावृत्ति के दौरान एक सरणी को संशोधित करते हैं, PHP परीक्षणों में पाया जा सकता है। आप इस परीक्षण से शुरू कर सकते हैं, फिर पते में 012 से 013 तक बदल सकते हैं, और इसी तरह। आप देखेंगे कि अलग-अलग स्थितियों (लिंक के संयोजन के सभी प्रकार, आदि) में खुद को कैसे प्रकट किया जाएगा।

अब अपने उदाहरणों पर वापस:

 foreach ($array as $item) { echo "$item\n"; $array[] = $item; } print_r($array); /* Output in loop: 1 2 3 4 5 $array after loop: 1 2 3 4 5 1 2 3 4 5 */ 

यहाँ $ सरणी में लूप से पहले refcount = 1 है, इसलिए इसे कॉपी नहीं किया जाएगा, लेकिन यह आडर्फ़र्ड प्राप्त करेगा। एक बार जब आप $ array [] को वैल्यू असाइन करते हैं, तो zval विभाजित हो जाएगा, इसलिए जिस array को आप एलिमेंट्स जोड़ते हैं और iterable array दो अलग-अलग ऐरे होंगे।

 foreach ($array as $key => $item) { $array[$key + 1] = $item + 2; echo "$item\n"; } print_r($array); /* Output in loop: 1 2 3 4 5 $array after loop: 1 3 4 5 6 7 */ 

पहले टेस्ट में जैसी स्थिति थी।

 //    ,  ,      foreach var_dump(each($array)); foreach ($array as $item) { echo "$item\n"; } var_dump(each($array)); /* Output array(4) { [1]=> int(1) ["value"]=> int(1) [0]=> int(0) ["key"]=> int(0) } 1 2 3 4 5 bool(false) */ 

फिर से वही कहानी। फॉरच लूप के दौरान, आपके पास refcount = 1 है और आपको केवल addref मिलता है, आंतरिक पॉइंटर $ अरेंज को बदल दिया जाएगा। लूप के अंत में, सूचक NULL हो जाता है (इसका अर्थ है कि पुनरावृत्ति पूर्ण है)। प्रत्येक गलत प्रदर्शन करके इसे प्रदर्शित करता है।

 foreach ($array as $key => $item) { echo "$item\n"; each($array); } /* Output: 1 2 3 4 5 */ 

 foreach ($array as $key => $item) { echo "$item\n"; reset($array); } /* Output: 1 2 3 4 5 */ 

प्रत्येक फ़ंक्शन और रीसेट दोनों को संदर्भ द्वारा संदर्भित किया जाता है। $ सरणी में उनके पास आने पर = 2 का रिफंड होता है, जिसके परिणामस्वरूप इसे विभाजित करना होगा। फिर से एक अलग सरणी पर काम करेगा।

लेकिन ये उदाहरण पर्याप्त नहीं हैं। जब आप लूप में करंट का उपयोग करते हैं तो व्यवहार वास्तव में अप्रत्याशित होने लगता है:

 foreach ($array as $val) { var_dump(current($array)); } /* Output: 2 2 2 2 2 */ 

यहां आपको यह ध्यान रखना चाहिए कि वर्तमान को भी संदर्भित किया जाता है, हालांकि यह सरणी को संशोधित नहीं करता है। यह अन्य सभी कार्यों के साथ कॉन्सर्ट में काम करने के लिए आवश्यक है, जैसे कि अगले, जो संदर्भ द्वारा पहुँचा जाता है (वर्तमान में, वास्तव में, एक रेफरी फ़ंक्शन है, यह एक मान प्राप्त कर सकता है, लेकिन लिंक का उपयोग करता है यदि यह कर सकता है)। संदर्भ का अर्थ है कि सरणी को अलग किया जाना चाहिए, इसलिए $ सरणी और $ सरणी की प्रतिलिपि जो फ़ॉरच का उपयोग करती है, वह स्वतंत्र होगी। आपको 2 क्यों मिलता है, 1 नहीं, ऊपर भी उल्लेख किया गया है: उपयोगकर्ता कोड की शुरुआत के लिए सरणी सूचक को फ़ॉरवर्ड करते हैं , और उसके बाद नहीं। इसलिए, भले ही कोड अभी भी पहले तत्व के साथ काम कर रहा है, फिर भी पहले से ही सूचक ने दूसरे को सूचक स्थानांतरित कर दिया है।

अब एक छोटा सा बदलाव करने की कोशिश करें:

 $ref = &$array; foreach ($array as $val) { var_dump(current($array)); } /* Output: 2 3 4 5 false */ 

यहां हमारे पास is_ref = 1 है, इसलिए सरणी कॉपी नहीं की गई है (ऊपर के रूप में)। लेकिन अब जब is_ref है, तो सरणी को वर्तमान के संदर्भ में पास करके, विभाजित होने की आवश्यकता नहीं है। अब करंट और फोरच एक ही एरे से काम करते हैं। आप सरणी को केवल एक के द्वारा स्थानांतरित किया हुआ देखते हैं क्योंकि फ़ॉर्चर सूचक को संभालता है।

आप एक ही चीज़ देखेंगे जब आप एक सरणी ट्रैवर्स लिंक द्वारा करेंगे:

 foreach ($array as &$val) { var_dump(current($array)); } /* Output: 2 3 4 5 false */ 

यहाँ सबसे महत्वपूर्ण बात यह है कि foreach हमारे $ array is_ref = 1 को असाइन करेगा जब यह संदर्भ द्वारा इसके चारों ओर लूप करेगा, इसलिए यह ऊपर जैसा होगा।

एक और छोटा बदलाव, यहां हम अपने एरे को दूसरे वेरिएबल में असाइन करेंगे:

 $foo = $array; foreach ($array as $val) { var_dump(current($array)); } /* Output: 1 1 1 1 1 */ 

यहां, लूप शुरू होने पर $ एरे का रिफंड 2 पर सेट होता है, इसलिए आपको शुरू करने से पहले एक कॉपी बनाने की आवश्यकता होती है। इस प्रकार, $ सरणी और foreach द्वारा उपयोग किए गए सरणी बहुत शुरुआत से अलग होंगे। इसलिए आपको उस सरणी के आंतरिक पॉइंटर की स्थिति मिलती है जो लूप की शुरुआत से पहले प्रासंगिक थी (इस मामले में, यह पहली स्थिति में थी)।

वस्तुओं का परिवर्तन

वस्तुओं पर पुनरावृत्ति करते समय, दो मामलों पर विचार करना समझ में आता है:

ऑब्जेक्ट ट्रैवर्सेबल नहीं है (या बल्कि, get_iterator आंतरिक हैंडलर परिभाषित नहीं है)

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

• घोषित गुणों के लिए, PHP गुणों की हैश तालिका को फिर से चुनता है। यदि आप ऑब्जेक्ट को पुनरावृत्त करते हैं, तो उसे इस हैश तालिका (जो मेमोरी उपयोग को बढ़ाती है) को फिर से संगठित करना चाहिए। ऐसा नहीं है कि आपको इस बारे में चिंता करनी चाहिए, बस ध्यान रखें।
• प्रत्येक पुनरावृत्ति पर, गुणों की हैश तालिका फिर से प्राप्त की जाएगी, अर्थात, PHP कॉल get_properties फिर से, और फिर से, और फिर से होगा। "साधारण" गुणों के लिए, यह इतना महत्वपूर्ण नहीं है, लेकिन यदि गुण गतिशील रूप से बनाए जाते हैं (अंतर्निहित कक्षाएं अक्सर ऐसा करती हैं), तो हर बार संपत्ति तालिका फिर से बनाई जाएगी।

ट्रैवर्सेबल ऑब्जेक्ट

इस मामले में, ऊपर कहा गया है कि किसी भी तरह से लागू नहीं किया जाएगा। इसके अलावा, PHP कॉपी नहीं करेगा और किसी भी ट्रिक का उपयोग नहीं करेगा जैसे कि पॉइंटर को बढ़ाना जब तक कि लूप पास न हो जाए। मुझे लगता है कि एक ट्रैवर्सेबल ऑब्जेक्ट के माध्यम से पारित होने की विधि बहुत अधिक अनुमानित है और इसके लिए और विवरण की आवश्यकता नहीं है।

लूप के दौरान चलने योग्य वस्तु को बदलना

एक और असामान्य मामला जिसका मैंने उल्लेख नहीं किया है वह यह है कि पीएचपी लूप के दौरान पुनरावृत्त वस्तु को बदलने की संभावना की अनुमति देता है। आप एक सरणी से शुरू कर सकते हैं और इसे आधे रास्ते से दूसरे स्थान पर जारी रख सकते हैं। या एक सरणी से शुरू करें, फिर उसे एक वस्तु से बदलें:

 $arr = [1, 2, 3, 4, 5]; $obj = (object) [6, 7, 8, 9, 10]; $ref =& $arr; foreach ($ref as $val) { echo "$val\n"; if ($val == 3) { $ref = $obj; } } /* Output: 1 2 3 6 7 8 9 10 */ 

जैसा कि आप देख सकते हैं, जैसे ही रिप्लेसमेंट हुआ, PHP ने दूसरी इकाई को बायपास करना शुरू कर दिया।

पुनरावृत्ति के दौरान किसी सरणी के आंतरिक पॉइंटर को बदलना

फॉरच व्यवहार का अंतिम विवरण, जिसका मैंने उल्लेख नहीं किया (क्योंकि इसका उपयोग वास्तव में अजीब व्यवहार प्राप्त करने के लिए किया जा सकता है ): यदि आप लूप करते समय सरणी के आंतरिक पॉइंटर को बदलने का प्रयास करते हैं तो क्या हो सकता है।

यहां आपको वह नहीं मिल सकता है जिसकी आपको उम्मीद थी: यदि आप लूप के शरीर में अगले या प्रचलित को कॉल करते हैं (संदर्भ से गुजरने के मामले में), तो आप देखेंगे कि आंतरिक पॉइंटर स्थानांतरित हो गया है, लेकिन इससे पुनरावृत्ति व्यवहार प्रभावित नहीं हुआ। इसका कारण यह है कि लूप के प्रत्येक दर्रे के बाद हैशपॉइंट में करंट पोजीशन और हैश तत्व में हैश का फोरच बैकअप होता है। अगले पास पर, यह देखने के लिए कि क्या आंतरिक हैटर की स्थिति बदल गई है और इस हैश का उपयोग करके इसे पुनर्स्थापित करने का प्रयास करने के लिए, फ़ॉरचेक जाँच करेगा।

आइए देखें कि इसका "प्रयास" करने का क्या अर्थ है। पहला उदाहरण दिखाता है कि आंतरिक पॉइंटर बदलने से फ़ॉरच मोड कैसे नहीं बदलता है:

 $array = [1, 2, 3, 4, 5]; $ref =& $array; foreach ($array as $value) { var_dump($value); reset($array); } // output: 1, 2, 3, 4, 5 

आइए अब पहले पास (कुंजी 1) पर आड़ू द्वारा पहुँचने वाले तत्व को अनसेट करने का प्रयास करें:

 $array = [1, 2, 3, 4, 5]; $ref =& $array; foreach ($array as $value) { var_dump($value); unset($array[1]); reset($array); } // output: 1, 1, 3, 4, 5 

यहां आप देखेंगे कि काउंटर को रीसेट कर दिया गया है, क्योंकि उपयुक्त हैश वाले तत्व को ढूंढना संभव नहीं था।

ध्यान रखें एक हैश सिर्फ एक हैश है। टकराव होता है। अब इसे आजमाते हैं:

 $array = ['EzEz' => 1, 'EzFY' => 2, 'FYEz' => 3]; $ref =& $array; foreach ($array as $value) { unset($array['EzFY']); $array['FYFZ'] = 4; reset($array); var_dump($value); } // output: 1 1 3 4 

यह हमारी अपेक्षा के अनुरूप काम करता है। हमने EzFY कुंजी (वह स्थान जहां फ़ॉरेस्ट था) को हटा दिया, इसलिए एक रीसेट किया गया था। हमने एक अतिरिक्त कुंजी भी जोड़ी है, इसलिए अंत में हम 4 देखते हैं।

और यहाँ अज्ञात आता है। यदि आप FYFY को FYFZ से बदल देते हैं तो क्या होगा? आइए कोशिश करते हैं:

 $array = ['EzEz' => 1, 'EzFY' => 2, 'FYEz' => 3]; $ref =& $array; foreach ($array as $value) { unset($array['EzFY']); $array['FYFY'] = 4; reset($array); var_dump($value); } // output: 1 4 

अब चक्र सीधे नए तत्व में चला गया है, बाकी सब को छोड़कर। ऐसा इसलिए है क्योंकि FYFY कुंजी में EzFY (वास्तव में, इस सरणी से सभी कुंजियाँ) के साथ टक्कर है। इसके अलावा, FYFY तत्व EzFY तत्व के समान मेमोरी पते पर स्थित है जिसे अभी हटा दिया गया है। तो PHP के लिए यह उसी हैश के साथ एक ही स्थिति होगी। स्थिति "बहाल" है और सरणी के अंत में संक्रमण है।