loops - PHP 'foreach' वास्तव में कैसे काम करता है?

foreach तीन अलग-अलग प्रकार के मूल्यों पर पुनरावृत्ति का समर्थन करता है:

• Arrays
• सामान्य वस्तुओं
• Traversable ऑब्जेक्ट्स

निम्नलिखित में मैं स्पष्ट रूप से व्याख्या करने की कोशिश करूंगा कि विभिन्न मामलों में पुनरावृत्ति कैसे काम करती है। अब तक का सबसे आसान मामला Traversable ऑब्जेक्ट्स है, क्योंकि इन foreach लिए अनिवार्य रूप से केवल इन पंक्तियों के साथ कोड के लिए वाक्यविन्यास चीनी है:

foreach ($it as $k => $v) { /* ... */ }

/* translates to: */

if ($it instanceof IteratorAggregate) {
    $it = $it->getIterator();
}
for ($it->rewind(); $it->valid(); $it->next()) {
    $v = $it->current();
    $k = $it->key();
    /* ... */
}

आंतरिक कक्षाओं के लिए एक आंतरिक एपीआई का उपयोग करके वास्तविक विधि कॉल से बचा जाता है जो अनिवार्य रूप से केवल सी स्तर पर Iterator इंटरफ़ेस को प्रतिबिंबित करता है।

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

वही ऑब्जेक्ट्स पर भी लागू होता है, क्योंकि ऑब्जेक्ट गुणों को उनके मूल्यों के साथ अन्य (ऑर्डर किए गए) शब्दकोश मैपिंग प्रॉपर्टी नामों के रूप में देखा जा सकता है, साथ ही कुछ दृश्यता हैंडलिंग भी। अधिकांश मामलों में ऑब्जेक्ट गुण वास्तव में इस अक्षम तरीके से संग्रहीत नहीं होते हैं। हालांकि यदि आप किसी ऑब्जेक्ट पर पुनरावृत्ति शुरू करते हैं, तो सामान्य रूप से उपयोग किए जाने वाले पैक किए गए प्रतिनिधित्व को वास्तविक शब्दकोश में परिवर्तित कर दिया जाएगा। उस बिंदु पर, सादे वस्तुओं का पुनरावृत्ति सरणी के पुनरावृत्ति के समान ही हो जाता है (यही कारण है कि मैं यहां सादा-वस्तु पुनरावृत्ति पर चर्चा नहीं कर रहा हूं)।

अब तक सब ठीक है. एक शब्दकोश पर इटरेट करना बहुत मुश्किल नहीं हो सकता है, है ना? समस्या तब शुरू होती है जब आप महसूस करते हैं कि पुनरावृत्ति के दौरान एक सरणी / वस्तु बदल सकती है। ऐसा होने के कई तरीके हैं:

• यदि आप foreach ($arr as &$v) का उपयोग करके संदर्भ द्वारा पुनरावृत्त करते हैं तो $arr को संदर्भ में बदल दिया जाता है और आप इसे पुनरावृत्ति के दौरान बदल सकते हैं।
• PHP 5 में वही लागू होता है, भले ही आप मान से पुन: प्रयास करते हैं, लेकिन सरणी पहले संदर्भ था: $ref =& $arr; foreach ($ref as $v) $ref =& $arr; foreach ($ref as $v)
• ऑब्जेक्ट्स पास सेमेन्टिक्स पास करने वाले हैंडल हैं, जो व्यावहारिक उद्देश्यों के लिए हैं, इसका मतलब है कि वे संदर्भों की तरह व्यवहार करते हैं। इसलिए वस्तुओं को पुनरावृत्ति के दौरान हमेशा बदला जा सकता है।

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

इस मुद्दे को हल करने के विभिन्न तरीके हैं। इस संबंध में PHP 5 और PHP 7 महत्वपूर्ण रूप से भिन्न हैं और मैं निम्नलिखित में दोनों व्यवहारों का वर्णन करूंगा। सारांश यह है कि PHP 5 का दृष्टिकोण बल्कि गूंगा था और सभी प्रकार के अजीब किनारे-मामले के मुद्दों का कारण बनता था, जबकि PHP 7 के अधिक शामिल दृष्टिकोण अधिक अनुमानित और लगातार व्यवहार में परिणाम देते थे।

एक अंतिम प्रारंभिक के रूप में, यह ध्यान दिया जाना चाहिए कि PHP संदर्भ गणना और स्मृति प्रबंधन के लिए प्रतिलिपि का उपयोग करता है। इसका अर्थ यह है कि यदि आप एक मूल्य की प्रतिलिपि बनाते हैं, तो आप वास्तव में पुराने मूल्य का पुन: उपयोग करते हैं और इसकी संदर्भ गणना (refcount) बढ़ाते हैं। केवल एक बार जब आप किसी प्रकार का संशोधन करते हैं तो वास्तविक प्रतिलिपि (जिसे "डुप्लिकेशन" कहा जाता है) किया जाएगा। देखें कि इस विषय पर अधिक विस्तृत परिचय के लिए आपको झूठ बोला जा रहा है ।

PHP 5

आंतरिक सरणी सूचक और हैश पॉइंटर

PHP 5 में Arrays में एक समर्पित "आंतरिक सरणी सूचक" (आईएपी) है, जो उचित रूप से संशोधनों का समर्थन करता है: जब भी कोई तत्व हटा दिया जाता है, तो यह जांच होगी कि आईएपी इस तत्व को इंगित करता है या नहीं। यदि ऐसा होता है, तो यह इसके बजाय अगले तत्व के लिए उन्नत है।

जबकि foreach आईएपी का उपयोग करता है, एक अतिरिक्त जटिलता है: केवल एक आईएपी है, लेकिन एक सरणी एकाधिक foreach loops का हिस्सा हो सकता है:

// Using by-ref iteration here to make sure that it's really
// the same array in both loops and not a copy
foreach ($arr as &$v1) {
    foreach ($arr as &$v) {
        // ...
    }
}

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

ऐरे डुप्लिकेशन

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

1. सरणी एक संदर्भ नहीं है (is_ref = 0)। यदि यह एक संदर्भ है, तो इसमें परिवर्तनों को प्रचारित किया जाना चाहिए, इसलिए इसे डुप्लिकेट नहीं किया जाना चाहिए।
2. सरणी refcount> 1 है। यदि रीफॉउंट 1 है, तो सरणी साझा नहीं की जाती है और हम इसे सीधे संशोधित करने के लिए स्वतंत्र हैं।

यदि सरणी डुप्लीकेट नहीं है (is_ref = 0, refcount = 1), तो केवल इसके refcount बढ़ाया जाएगा (*)। इसके अतिरिक्त, यदि संदर्भ द्वारा foreach का उपयोग किया जाता है, तो (संभावित रूप से डुप्लिकेट) सरणी संदर्भ में बदल दी जाएगी।

इस कोड को उदाहरण के रूप में देखें जहां डुप्लिकेशन होता है:

function iterate($arr) {
    foreach ($arr as $v) {}
}

$outerArr = [0, 1, 2, 3, 4];
iterate($arr);

यहां, $arr को $outerArr से लीक करने से $arr पर आईएपी परिवर्तनों को रोकने के लिए $arr को डुप्लिकेट किया जाएगा। उपरोक्त स्थितियों के संदर्भ में, सरणी एक संदर्भ नहीं है (is_ref = 0) और दो स्थानों (refcount = 2) में प्रयोग किया जाता है। यह आवश्यकता दुर्भाग्यपूर्ण है और उपनिवेश कार्यान्वयन का एक आर्टिफैक्ट है (यहां पुनरावृत्ति के दौरान संशोधन की कोई चिंता नहीं है, इसलिए हमें वास्तव में पहली बार आईएपी का उपयोग करने की आवश्यकता नहीं है)।

(*) यहां रेफकाउंट बढ़ाने से निर्दोष लगता है, लेकिन कॉपी-ऑन-राइट (गाय) अर्थशास्त्र का उल्लंघन करता है: इसका मतलब है कि हम एक refcount = 2 सरणी के आईएपी को संशोधित करने जा रहे हैं, जबकि गाय निर्देशित करता है कि संशोधनों को केवल refcount पर ही किया जा सकता है = 1 मान इस उल्लंघन के परिणामस्वरूप उपयोगकर्ता-दृश्य व्यवहार में परिवर्तन होता है (जबकि गाय सामान्य रूप से पारदर्शी होता है), क्योंकि पुनरावृत्त सरणी पर आईएपी परिवर्तन देखने योग्य होगा - लेकिन केवल सरणी पर पहले गैर-आईएपी संशोधन तक ही। इसके बजाए, तीन "मान्य" विकल्प हमेशा एक डुप्लिकेट करने के लिए होते थे, बी) रिफॉउंट बढ़ाने में वृद्धि नहीं करते हैं और इस प्रकार पुनरावर्तित सरणी को लूप में मनमाने ढंग से संशोधित करने की इजाजत दी जाती है, या सी) आईएपी का बिल्कुल उपयोग नहीं करते हैं ( PHP 7 समाधान)।

स्थिति उन्नति आदेश

एक अंतिम कार्यान्वयन विवरण है कि आपको नीचे दिए गए कोड नमूने को सही ढंग से समझने के बारे में पता होना चाहिए। कुछ डेटा संरचना के माध्यम से लूपिंग का "सामान्य" तरीका छद्म कोड में ऐसा कुछ दिखाई देगा:

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

हालांकि, विशेष रूप से विशेष हिमपात होने के कारण, चीजों को थोड़ा अलग तरीके से करने का विकल्प चुनता है:

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

अर्थात्, लूप बॉडी चलाने से पहले सरणी सूचक पहले से ही आगे बढ़ गया है। इसका मतलब है कि जबकि लूप बॉडी तत्व $i पर काम कर रहा है, आईएपी पहले से ही तत्व $i+1 । यही कारण है कि पुनरावृत्ति के दौरान संशोधन दिखाने वाले कोड नमूने हमेशा मौजूदा तत्व की बजाय अगले तत्व को अनसेट करेंगे।

उदाहरण: आपके परीक्षण के मामले

ऊपर वर्णित तीन पहलुओं को आपको फोरैच कार्यान्वयन की मूर्खता की पूरी तरह से पूर्ण प्रभाव प्रदान करना चाहिए और हम कुछ उदाहरणों पर चर्चा करने के लिए आगे बढ़ सकते हैं।

आपके परीक्षण मामलों का व्यवहार इस बिंदु पर व्याख्या करना सरल है:

• परीक्षण मामलों में 1 और 2 $array refcount = 1 के साथ शुरू होती है, इसलिए इसे foreach द्वारा डुप्लीकेट नहीं किया जाएगा: केवल refcount वृद्धि हुई है। जब लूप बॉडी बाद में सरणी को संशोधित करता है (जिसने उस बिंदु पर refcount = 2 है), उस बिंदु पर डुप्लिकेशन होगा। Foreach $array की एक unmodified प्रति पर काम करना जारी रखेगा।

• परीक्षण मामले 3 में, एक बार फिर सरणी डुप्लिकेट नहीं की जाती है, इस प्रकार foreach $array के आईएपी को संशोधित करेगा। पुनरावृत्ति के अंत में आईएपी न्यूल (जिसका अर्थ है पुनरावृत्ति), जो each false लौटकर इंगित करता है।

• परीक्षण मामलों में 4 और 5 each और reset दोनों संदर्भ-संदर्भ कार्य हैं। $array में एक refcount=2 होता है जब इसे पास किया जाता है, इसलिए इसे डुप्लिकेट करना होगा। जैसे कि foreach फिर से एक अलग सरणी पर काम करेगा।

उदाहरण: foreach में current प्रभाव

विभिन्न डुप्लिकेशन व्यवहार दिखाने का एक अच्छा तरीका एक foreach पाश के अंदर current() फ़ंक्शन के व्यवहार का निरीक्षण करना है। इस उदाहरण पर विचार करें:

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

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

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

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

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

उप-पुनरावृत्ति करते समय आपको वही व्यवहार मिलता है:

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

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

उदाहरण: पुनरावृत्ति के दौरान संशोधन

पुनरावृत्ति के दौरान संशोधन के लिए खाते की कोशिश करना वह जगह है जहां हमारी सभी foreach परेशानियों की उत्पत्ति हुई, इसलिए यह इस मामले के लिए कुछ उदाहरणों पर विचार करता है।

इन घोंसले वाले लूपों को एक ही सरणी पर विचार करें (जहां से रेफरी पुनरावृत्ति का उपयोग यह सुनिश्चित करने के लिए किया जाता है कि यह वास्तव में वही है):

foreach ($array as &$v1) {
    foreach ($array as &$v2) {
        if ($v1 == 1 && $v2 == 1) {
            unset($array[1]);
        }
        echo "($v1, $v2)\n";
    }
}

// Output: (1, 1) (1, 3) (1, 4) (1, 5)

यहां अपेक्षित हिस्सा यह है कि (1, 2) आउटपुट से गायब है, क्योंकि तत्व 1 हटा दिया गया था। शायद अप्रत्याशित रूप से यह है कि बाहरी लूप पहले तत्व के बाद बंद हो जाता है। ऐसा क्यों है?

इसके पीछे कारण नेस्टेड-लूप हैक ऊपर वर्णित है: लूप बॉडी चलाने से पहले, वर्तमान आईएपी स्थिति और हैश को हैश HashPointer में बैक अप किया जाता है। लूप बॉडी के बाद इसे बहाल किया जाएगा, लेकिन केवल तभी तत्व मौजूद है, अन्यथा वर्तमान आईएपी स्थिति (जो कुछ भी हो) इसके बजाए प्रयोग किया जाता है। उपर्युक्त उदाहरण में यह बिल्कुल मामला है: बाहरी पाश का वर्तमान तत्व हटा दिया गया है, इसलिए यह आईएपी का उपयोग करेगा, जिसे पहले से ही आंतरिक लूप द्वारा समाप्त किया गया है!

HashPointer बैकअप + पुनर्स्थापना तंत्र का एक और परिणाम यह है कि आईएपी में परिवर्तन हालांकि reset() इत्यादि आमतौर पर HashPointer को प्रभावित नहीं करते हैं। उदाहरण के लिए, निम्न कोड निष्पादित करता है जैसे reset() बिल्कुल मौजूद नहीं थे:

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

इसका कारण यह है कि, जबकि reset() अस्थायी रूप से आईएपी को संशोधित करता है, इसे लूप बॉडी के बाद वर्तमान foreach तत्व में बहाल किया जाएगा। लूप पर प्रभाव डालने के लिए reset() को मजबूर reset() लिए, आपको अतिरिक्त तत्व को अतिरिक्त रूप से निकालना होगा, ताकि बैकअप / पुनर्स्थापना तंत्र विफल हो जाए:

$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

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

$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

यहां हमें सामान्य नियमों के अनुसार सामान्य रूप से आउटपुट 1, 1, 3, 4 अपेक्षा करनी चाहिए। कैसे होता है कि 'FYFY' में हटाए गए तत्व 'EzFY' के समान हैश है, और 'EzFY' तत्व को संग्रहीत करने के लिए उसी स्मृति स्थान का पुन: उपयोग करने के लिए होता है। इसलिए foreach सीधे नए डालने वाले तत्व पर कूदता है, इस प्रकार लूप को छोटा कर देता है।

लूप के दौरान पुनरावृत्त इकाई को प्रतिस्थापित करना

एक आखिरी अजीब मामला जिसे मैं उल्लेख करना चाहता हूं, यह है कि 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 प्रतिस्थापन होने के बाद ही शुरुआत से दूसरी इकाई को फिर से शुरू करना शुरू कर देगा।

PHP 7

हैशटेबल इटरेटर्स

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

PHP 7 एक अलग दृष्टिकोण का उपयोग करता है, अर्थात् यह बाहरी, सुरक्षित हैशटेबल इटरेटर्स की मनमानी मात्रा बनाने में सहायता करता है। इन इटरेटर को सरणी में पंजीकृत होना होता है, जिस बिंदु से उनके पास आईएपी के समान अर्थशास्त्र होते हैं: यदि कोई सरणी तत्व हटा दिया जाता है, तो उस तत्व को इंगित करने वाले सभी हैशटेबल इटरेटर अगले तत्व में उन्नत हो जाएंगे।

इसका मतलब है कि foreach अब आईएपी का उपयोग नहीं करेगा। फोरैच लूप current() इत्यादि के परिणामों पर बिल्कुल प्रभाव नहीं डालेगा और इसका अपना व्यवहार कभी भी reset() इत्यादि जैसे कार्यों से प्रभावित नहीं होगा।

ऐरे डुप्लिकेशन

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

ज्यादातर मामलों में यह परिवर्तन पारदर्शी है और बेहतर प्रदर्शन से कोई अन्य प्रभाव नहीं है। हालांकि एक अवसर है जहां इसका परिणाम अलग-अलग व्यवहार में होता है, अर्थात् वह मामला जहां सरणी पहले संदर्भ था:

$array = [1, 2, 3, 4, 5];
$ref = &$array;
foreach ($array as $val) {
    var_dump($val);
    $array[2] = 0;
}
/* Old output: 1, 2, 0, 4, 5 */
/* New output: 1, 2, 3, 4, 5 */

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

यह, ज़ाहिर है, संदर्भ संदर्भ पर लागू नहीं होता है। यदि आप संदर्भ के अनुसार पुनरावृत्त करते हैं तो सभी संशोधनों को लूप द्वारा प्रतिबिंबित किया जाएगा। दिलचस्प बात यह है कि सादे वस्तुओं के मूल्य-मूल्य पुनरावृत्ति के लिए भी यही सच है:

$obj = new stdClass;
$obj->foo = 1;
$obj->bar = 2;
foreach ($obj as $val) {
    var_dump($val);
    $obj->bar = 42;
}
/* Old and new output: 1, 42 */

यह ऑब्जेक्ट्स द्वारा उप-संभाल अर्थात् प्रतिबिंबित करता है (यानी वे संदर्भ-व्यवहार के समान-संदर्भ में भी व्यवहार करते हैं)।

उदाहरण

आइए अपने परीक्षण मामलों से शुरू होने वाले कुछ उदाहरणों पर विचार करें:

• टेस्ट केस 1 और 2 एक ही आउटपुट को बनाए रखते हैं: बाय-वैल्यू सरणी पुनरावृत्ति हमेशा मूल तत्वों पर काम करती रहती है। (इस मामले में PHP 5 और PHP 7 के बीच भी refcounting और डुप्लिकेशन व्यवहार समान है)।

• टेस्ट केस 3 में परिवर्तन: Foreach अब आईएपी का उपयोग नहीं करता है, इसलिए each() लूप से प्रभावित नहीं होता है। इससे पहले और बाद में एक ही आउटपुट होगा।

• टेस्ट केस 4 और 5 वही रहते हैं: each() और reset() आईएपी को बदलने से पहले सरणी को डुप्लिकेट करेगा, जबकि foreach अभी भी मूल सरणी का उपयोग करता है। (यह नहीं कि आईएपी परिवर्तन परिपक्व होगा, भले ही सरणी साझा की गई हो।)

उदाहरणों का दूसरा सेट अलग-अलग संदर्भ / refcounting विन्यास के तहत current() के व्यवहार से संबंधित था। यह अब समझ में नहीं आता है, क्योंकि current() लूप द्वारा पूरी तरह से अप्रभावित है, इसलिए इसका वापसी मूल्य हमेशा रहता है।

हालांकि, पुनरावृत्ति के दौरान संशोधन पर विचार करते समय हमें कुछ दिलचस्प बदलाव मिलते हैं। मुझे उम्मीद है कि आपको नया व्यवहार अधिक सचेत मिलेगा। पहला उदाहरण:

$array = [1, 2, 3, 4, 5];
foreach ($array as &$v1) {
    foreach ($array as &$v2) {
        if ($v1 == 1 && $v2 == 1) {
            unset($array[1]);
        }
        echo "($v1, $v2)\n";
    }
}

// Old output: (1, 1) (1, 3) (1, 4) (1, 5)
// New output: (1, 1) (1, 3) (1, 4) (1, 5)
//             (3, 1) (3, 3) (3, 4) (3, 5)
//             (4, 1) (4, 3) (4, 4) (4, 5)
//             (5, 1) (5, 3) (5, 4) (5, 5) 

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

अब एक और अजीब किनारा मामला तय किया गया है, जब आप एक ही हैश होने वाले तत्वों को हटाते हैं और जोड़ते हैं तो यह अजीब प्रभाव होता है:

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

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

स्पष्टीकरण ( php.net से उद्धरण):

सरणी_एक्सप्रेस द्वारा दिए गए सरणी पर पहला फॉर्म लूप। प्रत्येक पुनरावृत्ति पर, वर्तमान तत्व का मान $ मान को सौंपा गया है और आंतरिक सरणी सूचक एक द्वारा उन्नत है (इसलिए अगली पुनरावृत्ति पर, आप अगले तत्व को देखेंगे)।

तो, आपके पहले उदाहरण में आपके पास केवल सरणी में एक तत्व है, और जब सूचक स्थानांतरित हो जाता है तो अगला तत्व मौजूद नहीं होता है, इसलिए जब आप नया तत्व फोरच जोड़ते हैं तो यह पहले से ही "तय" होता है कि यह अंतिम तत्व के रूप में होता है।

आपके दूसरे उदाहरण में, आप दो तत्वों से शुरू करते हैं, और फ़ोरैच लूप अंतिम तत्व पर नहीं है, इसलिए यह अगले पुनरावृत्ति पर सरणी का मूल्यांकन करता है और इस प्रकार यह महसूस करता है कि सरणी में नया तत्व है।

मेरा मानना ​​है कि दस्तावेज़ीकरण में स्पष्टीकरण के प्रत्येक पुनरावृत्ति भाग पर यह सब परिणाम है, जिसका अर्थ है कि foreach {} में कोड को कॉल करने से पहले सभी तर्क करता है।

परीक्षण का मामला

यदि आप इसे चलाते हैं:

<?
    $array = Array(
        'foo' => 1,
        'bar' => 2
    );
    foreach($array as $k=>&$v) {
        $array['baz']=3;
        echo $v." ";
    }
    print_r($array);
?>

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

1 2 3 Array
(
    [foo] => 1
    [bar] => 2
    [baz] => 3
)

जिसका अर्थ यह है कि उसने संशोधन स्वीकार कर लिया और इसके माध्यम से चला गया क्योंकि इसे "समय में" संशोधित किया गया था। लेकिन अगर आप ऐसा करते हैं:

<?
    $array = Array(
        'foo' => 1,
        'bar' => 2
    );
    foreach($array as $k=>&$v) {
        if ($k=='bar') {
            $array['baz']=3;
        }
        echo $v." ";
    }
    print_r($array);
?>

You will get:

1 2 Array
(
    [foo] => 1
    [bar] => 2
    [baz] => 3
)

Which means that array was modified, but since we modified it when the foreach already was at the last element of the array, it "decided" not to loop anymore, and even though we added new element, we added it "too late" and it was not looped through.

Detailed explanation can be read at How does PHP 'foreach' actually work? which explains the internals behind this behaviour.

उदाहरण 3 में आप सरणी को संशोधित नहीं करते हैं। अन्य सभी उदाहरणों में आप या तो सामग्री या आंतरिक सरणी सूचक को संशोधित करते हैं। जब यह असाइनमेंट ऑपरेटर के अर्थशास्त्र के कारण PHP arrays की बात आती है तो यह महत्वपूर्ण है।

PHP में सरणी के लिए असाइनमेंट ऑपरेटर आलसी क्लोन की तरह काम करता है। एक वैरिएबल को दूसरे में असाइन करना जिसमें एक सरणी है, अधिकांश भाषाओं के विपरीत सरणी को क्लोन कर देगी। हालांकि, वास्तविक क्लोनिंग तब तक नहीं की जाएगी जब तक इसकी आवश्यकता न हो। इसका मतलब यह है कि क्लोन तभी होगा जब किसी भी चर को संशोधित किया जाए (प्रतिलिपि लिखना)।

यहाँ एक उदाहरण है:

$a = array(1,2,3);
$b = $a;  // This is lazy cloning of $a. For the time
          // being $a and $b point to the same internal
          // data structure.

$a[] = 3; // Here $a changes, which triggers the actual
          // cloning. From now on, $a and $b are two
          // different data structures. The same would
          // happen if there were a change in $b.

अपने परीक्षण मामलों में वापस आकर, आप आसानी से कल्पना कर सकते हैं कि foreach सरणी के संदर्भ के साथ किसी प्रकार का इटरेटर बनाता है। यह संदर्भ बिल्कुल मेरे उदाहरण में परिवर्तनीय $b तरह काम करता है। हालांकि, संदर्भ के साथ इटेटरेटर केवल लूप के दौरान रहता है और फिर, दोनों को त्याग दिया जाता है। अब आप देख सकते हैं कि, सभी मामलों में लेकिन 3, लूप के दौरान सरणी संशोधित की जाती है, जबकि यह अतिरिक्त संदर्भ जीवित है। यह एक क्लोन ट्रिगर करता है, और यह बताता है कि यहां क्या हो रहा है!

इस कॉपी-ऑन-राइट व्यवहार के किसी अन्य दुष्प्रभाव के लिए यहां एक उत्कृष्ट लेख है: PHP टर्नरी ऑपरेटर: तेज़ या नहीं?

PHP foreach loop can be used with Indexed arrays , Associative arrays and Object public variables .

In foreach loop, the first thing php does is that it creates a copy of the array which is to be iterated over. PHP then iterates over this new copy of the array rather than the original one. This is demonstrated in the below example:

<?php
$numbers = [1,2,3,4,5,6,7,8,9]; # initial values for our array
echo '<pre>', print_r($numbers, true), '</pre>', '<hr />';
foreach($numbers as $index => $number){
    $numbers[$index] = $number + 1; # this is making changes to the origial array
    echo 'Inside of the array = ', $index, ': ', $number, '<br />'; # showing data from the copied array
}
echo '<hr />', '<pre>', print_r($numbers, true), '</pre>'; # shows the original values (also includes the newly added values).

Besides this, php does allow to use iterated values as a reference to the original array value as well. This is demonstrated below:

<?php
$numbers = [1,2,3,4,5,6,7,8,9];
echo '<pre>', print_r($numbers, true), '</pre>';
foreach($numbers as $index => &$number){
    ++$number; # we are incrementing the original value
    echo 'Inside of the array = ', $index, ': ', $number, '<br />'; # this is showing the original value
}
echo '<hr />';
echo '<pre>', print_r($numbers, true), '</pre>'; # we are again showing the original value

Note: It does not allow original array indexes to be used as references .

Source: http://dwellupper.io/post/47/understanding-php-foreach-loop-with-examples

Great question, because many developers, even experienced ones, are confused by the way PHP handles arrays in foreach loops. In the standard foreach loop, PHP makes a copy of the array that is used in the loop. The copy is discarded immediately after the loop finishes. This is transparent in the operation of a simple foreach loop. उदाहरण के लिए:

$set = array("apple", "banana", "coconut");
foreach ( $set AS $item ) {
    echo "{$item}\n";
}

This outputs:

apple
banana
coconut

So the copy is created but the developer doesn't notice, because the original array isn't referenced within the loop or after the loop finishes. However, when you attempt to modify the items in a loop, you find that they are unmodified when you finish:

$set = array("apple", "banana", "coconut");
foreach ( $set AS $item ) {
    $item = strrev ($item);
}

print_r($set);

This outputs:

Array
(
    [0] => apple
    [1] => banana
    [2] => coconut
)

Any changes from the original can't be notices, actually there are no changes from the original, even though you clearly assigned a value to $item. This is because you are operating on $item as it appears in the copy of $set being worked on. You can override this by grabbing $item by reference, like so:

$set = array("apple", "banana", "coconut");
foreach ( $set AS &$item ) {
    $item = strrev($item);
}
print_r($set);

This outputs:

Array
(
    [0] => elppa
    [1] => ananab
    [2] => tunococ
)

So it is evident and observable, when $item is operated on by-reference, the changes made to $item are made to the members of the original $set. Using $item by reference also prevents PHP from creating the array copy. To test this, first we'll show a quick script demonstrating the copy:

$set = array("apple", "banana", "coconut");
foreach ( $set AS $item ) {
    $set[] = ucfirst($item);
}
print_r($set);

This outputs:

Array
(
    [0] => apple
    [1] => banana
    [2] => coconut
    [3] => Apple
    [4] => Banana
    [5] => Coconut
)

As it is shown in the example, PHP copied $set and used it to loop over, but when $set was used inside the loop, PHP added the variables to the original array, not the copied array. Basically, PHP is only using the copied array for the execution of the loop and the assignment of $item. Because of this, the loop above only executes 3 times, and each time it appends another value to the end of the original $set, leaving the original $set with 6 elements, but never entering an infinite loop.

However, what if we had used $item by reference, as I mentioned before? A single character added to the above test:

$set = array("apple", "banana", "coconut");
foreach ( $set AS &$item ) {
    $set[] = ucfirst($item);
}
print_r($set);

Results in an infinite loop. Note this actually is an infinite loop, you'll have to either kill the script yourself or wait for your OS to run out of memory. I added the following line to my script so PHP would run out of memory very quickly, I suggest you do the same if you're going to be running these infinite loop tests:

ini_set("memory_limit","1M");

So in this previous example with the infinite loop, we see the reason why PHP was written to create a copy of the array to loop over. When a copy is created and used only by the structure of the loop construct itself, the array stays static throughout the execution of the loop, so you'll never run into issues.

यह निर्धारित करने के लिए कि किसी स्ट्रिंग में कोई अन्य स्ट्रिंग है या नहीं, आप PHP फ़ंक्शन strpos() उपयोग कर सकते हैं।

int strpos ( string $haystack , mixed $needle [, int $offset = 0 ] )

<?php

$haystack = 'how are you';
$needle = 'are';

if (strpos($haystack,$needle) !== false) {
    echo "$haystack contains $needle";
}

?>

सावधान:

यदि आप जिस सुई की खोज कर रहे हैं वह हैस्टैक की शुरुआत में है तो यह स्थिति 0 लौटाएगी, अगर आप एक == तुलना करते हैं जो काम नहीं करेगा, तो आपको एक ===

ए == संकेत एक तुलना है और परीक्षण करता है कि बाईं ओर परिवर्तनीय / अभिव्यक्ति / स्थिरांक वैरिएबल / अभिव्यक्ति / दाईं ओर स्थिर के समान मान है।

ए === संकेत यह देखने के लिए एक तुलना है कि दो चर / एक्सपेशंस / स्थिरांक बराबर हैं AND समान प्रकार हैं - यानी दोनों स्ट्रिंग हैं या दोनों पूर्णांक हैं।