PHP नेस्टेड फ़ंक्शन किसके लिए हैं?

Question 1

जावास्क्रिप्ट में नेस्टेड फ़ंक्शन बहुत उपयोगी हैं: क्लोजर, निजी तरीके और आपके पास क्या है ..

नेस्टेड PHP फ़ंक्शन किसके लिए हैं? क्या कोई उनका उपयोग करता है और किस लिए?

यहाँ एक छोटी सी जाँच मैंने की है

<?php
function outer( $msg ) {
    function inner( $msg ) {
        echo 'inner: '.$msg.' ';
    }
    echo 'outer: '.$msg.' ';
    inner( $msg );
}

inner( 'test1' );  // Fatal error:  Call to undefined function inner()
outer( 'test2' );  // outer: test2 inner: test2
inner( 'test3' );  // inner: test3
outer( 'test4' );  // Fatal error:  Cannot redeclare inner()

Question 2

मूल रूप से कोई नहीं है। मैंने हमेशा इसे पार्सर के साइड इफेक्ट के रूप में माना है।

Eran Galperin को यह सोचने में गलत समझा जाता है कि ये कार्य किसी तरह निजी हैं। उन्हें बस outer()चलाने तक अघोषित किया जाता है। वे निजी तौर पर भी नहीं हैं; वे वैश्विक दायरे को प्रदूषित करते हैं, भले ही देरी हुई हो। और कॉलबैक के रूप में, बाहरी कॉलबैक को अभी भी केवल एक बार कॉल किया जा सकता है। मैं अभी भी यह नहीं देखता कि इसे एक सरणी पर लागू करना कैसे उपयोगी है, जो बहुत संभावना है कि उपनाम एक से अधिक बार कॉल करता है।

एकमात्र 'वास्तविक दुनिया' का उदाहरण जो मैं खोद सकता था वह यह है , जो केवल एक बार चल सकता है, और क्लीनर को फिर से लिखा जा सकता है, आईएमओ।

एकमात्र ऐसा [name]_includeतरीका जिसके बारे में मैं सोच सकता हूं, वह मॉड्यूल के लिए एक विधि को कॉल करने के लिए है, जो वैश्विक अंतरिक्ष में कई नेस्टेड तरीकों को संयुक्त रूप से सेट करता है

if (!function_exists ('somefunc')) {
  function somefunc() { }
}

जाँच करता है।

PHP का OOP स्पष्ट रूप से एक बेहतर विकल्प होगा :)

Question 3

यदि आप PHP 5.3 का उपयोग कर रहे हैं, तो आप एक गुमनाम फ़ंक्शन के साथ अधिक Javacript- जैसा व्यवहार प्राप्त कर सकते हैं:

<?php
function outer() {
    $inner=function() {
        echo "test\n";
    };

    $inner();
}

outer();
outer();

inner(); //PHP Fatal error:  Call to undefined function inner()
$inner(); //PHP Fatal error:  Function name must be a string
?>

आउटपुट:

test
test

Question 4

[@PierredeLESPINAY द्वारा टिप्पणी के अनुसार लिखा गया।]

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

उदाहरण के लिए, यदि आप गतिशील रूप से / सशर्त रूप से अपने ढांचे से प्लग-इन लोड करते हैं, और प्लगइन लेखकों के जीवन को सुपर आसान बनाना चाहते हैं, तो आप कुछ महत्वपूर्ण कार्यों के लिए डिफ़ॉल्ट कार्यान्वयन प्रदान कर सकते हैं जो प्लगइन ओवरराइड नहीं किया था:

<?php // Some framework module

function provide_defaults()
{
    // Make sure a critical function exists:
    if (!function_exists("tedious_plugin_callback"))
    {
        function tedious_plugin_callback()
        {
        // Complex code no plugin author ever bothers to customize... ;)
        }
    }
}

Question 5

फ़ंक्शंस के भीतर परिभाषित फ़ंक्शंस, मैं सशर्त रूप से परिभाषित फ़ंक्शंस के लिए बहुत उपयोग नहीं देख सकता। उदाहरण के लिए:

if ($language == 'en') {
  function cmp($a, $b) { /* sort by English word order */ }
} else if ($language == 'de') {
  function cmp($a, $b) { /* sort by German word order; yes it's different */ }
} // etc

और फिर आपके सभी कोड को यूआरओटी () कॉल जैसी चीजों में 'सीएमपी' फ़ंक्शन का उपयोग करना होगा ताकि आप अपने कोड पर सभी भाषा की जाँच न करें। अब मैंने ऐसा नहीं किया है लेकिन मैं इसे करने के लिए तर्क देख सकता हूं।

Question 6

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

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

सामान्यतया, जावास्क्रिप्ट के रूप में मानक का उपयोग करके अन्य सी आधारित प्रोग्रामिंग भाषाओं का मूल्यांकन करना एक बुरा विचार है। PHP, Python, Perl, C, C ++ और Java की तुलना में जावास्क्रिप्ट निश्चित रूप से अपना जानवर है। बेशक, बहुत सारी सामान्य समानताएं हैं, लेकिन नीटी, किरकिरा विवरण (संदर्भ जावास्क्रिप्ट: निश्चित गाइड, 6 वें संस्करण, अध्याय 1-12 ), जब ध्यान दिया जाता है, तो कोर जावास्क्रिप्ट को अद्वितीय, सुंदर, अलग, सरल और एक ही समय में सभी जटिल। वह मेरा दो सेंट है।

बस स्पष्ट होना, मैं नहीं कह रहा हूँ नेस्टेड कार्य निजी हैं। बस उस घोंसले के शिकार से अव्यवस्था से बचने में मदद मिल सकती है जब कुछ तुच्छ को संशोधित करने की आवश्यकता होती है (और केवल मूल कार्य द्वारा आवश्यक है)।

Question 7

मेरे सभी php OO हैं, लेकिन मुझे नेस्टेड फ़ंक्शन के लिए एक उपयोग दिखाई देता है, खासकर जब आपका फ़ंक्शन पुनरावर्ती है और जरूरी नहीं कि एक ऑब्जेक्ट हो। कहने का तात्पर्य यह है कि इसे जिस फ़ंक्शन में नेस्ट किया जाता है, उसके बाहर नहीं बुलाया जाता है, लेकिन पुनरावर्ती है और बाद में फ़ंक्शन करने की आवश्यकता होती है।

एक एकल विधि के एक्सप्रेस उपयोग के लिए एक नई विधि बनाने में बहुत कम बिंदु है। मेरे लिए यह अनाड़ी कोड है और सॉर्ट-ओओ का बिंदु नहीं है। यदि आप उस फ़ंक्शन को कभी भी कहीं और कॉल नहीं करने जा रहे हैं, तो उसे घोंसला दें।

Question 8

Webservice कॉलिंग में हमने पाया कि यह एक बहुत कम ओवरहेड (मेमोरी और गति) है, एक नेस्टेड फैशन में, विभिन्न कार्यों के पुस्तकालयों से भरे व्यक्तिगत कार्यों सहित। ठेठ कॉल स्टैक 5-10 कॉल के बीच हो सकता है गहरी केवल एक दर्जन 1-2kb फ़ाइलों को जोड़ने की आवश्यकता होती है गतिशील रूप से मेगाबाइट सहित बेहतर था। यह केवल एक छोटा सा उपयोग फ़ंक्शन रैपिंग बनाने के लिए आवश्यक था। शामिल फ़ंक्शन कॉल स्टैक के ऊपर फ़ंक्शन के भीतर नेस्टेड हो जाते हैं। यह उन 100 कार्यों से भरी कक्षाओं के विपरीत है, जिन पर हर वेबसर्विस कॉल की आवश्यकता नहीं थी, लेकिन इसमें php की इनबिल्ट लेज़ी लोडिंग सुविधाओं का भी उपयोग किया जा सकता था।

Question 9

यदि आप php 7 में हैं, तो इसे देखें: यह कार्यान्वयन आपको नेस्टेड फ़ंक्शन के बारे में एक स्पष्ट विचार देगा। मान लीजिए कि हमारे पास तीन फ़ंक्शन (भी), बू () और चिड़ियाघर ()) फंक्शन फू में निहित हैं। बू () और चिड़ियाघर () में एक ही नामांकित फ़ंक्शन xoo () है। अब इस कोड में मैंने नेस्टेड फ़ंक्शन के नियमों को स्पष्ट रूप से टिप्पणी की है।

   function foo(){
        echo 'foo() is called'.'<br>';
        function too(){
            echo 'foo()->too() is called'.'<br>';
        }
        function boo(){
            echo 'foo()->boo() is called'.'<br>';
            function xoo(){
                echo 'foo()->boo()->xoo() is called'.'<br>';
            }
            function moo(){
                echo 'foo()->boo()->moo() is called'.'<br>';
            }
        }
        function zoo(){
            echo 'foo()->zoo() is called'.'<br>';
            function xoo(){     //same name as used in boo()->xoo();
                echo 'zoo()->xoo() is called'.'<br>';
            }
        #we can use same name for nested function more than once 
        #but we can not call more than one of the parent function
        }
    }

/****************************************************************
 * TO CALL A INNER FUNCTION YOU MUST CALL OUTER FUNCTIONS FIRST *
 ****************************************************************/
    #xoo();//error: as we have to declare foo() first as xoo() is nested in foo()

    function test1(){
        echo '<b>test1:</b><br>';
        foo(); //call foo()
        too();
        boo();
        too(); // we can can a function twice
        moo(); // moo() can be called as we have already called boo() and foo()
        xoo(); // xoo() can be called as we have already called boo() and foo()
        #zoo(); re-declaration error
        //we cannont call zoo() because we have already called boo() and both of them have same named nested function xoo()
    }

    function test2(){
        echo '<b>test2:</b><br>';
        foo(); //call foo()
        too();
        #moo(); 
        //we can not call moo() as the parent function boo() is not yet called
        zoo(); 
        xoo();
        #boo(); re-declaration error
        //we cannont call boo() because we have already called zoo() and both of them have same named nested function xoo()

    }

अब अगर हम test1 () कहते हैं तो आउटपुट यह होगा:

test1:
foo() is called
foo()->too() is called
foo()->boo() is called
foo()->too() is called
foo()->boo()->moo() is called
foo()->boo()->xoo() is called

अगर हम test2 () कहते हैं तो आउटपुट यह होगा:

test2:
foo() is called
foo()->too() is called
foo()->zoo() is called
zoo()->xoo() is called

लेकिन हम पुन: घोषणा त्रुटि से बचने के लिए एक ही समय में text1 () और test2 () दोनों को कॉल नहीं कर सकते

Question 10

मुझे पता है कि यह एक पुरानी पोस्ट है, लेकिन fwiw मैं नेस्टेड फ़ंक्शंस का उपयोग एक पुनरावर्ती कॉल के लिए एक साफ और सुव्यवस्थित दृष्टिकोण देने के लिए करता हूं, जब मुझे केवल स्थानीय रूप से कार्यक्षमता की आवश्यकता होती है - उदाहरण के लिए पदानुक्रमित ऑब्जेक्ट आदि के निर्माण के लिए (जाहिर है कि आपको माता-पिता के कार्य से सावधान रहना होगा एक बार कहा जाता है):

function main() {
    // Some code

    function addChildren ($parentVar) {
        // Do something
        if ($needsGrandChildren) addChildren ($childVar);
    }
    addChildren ($mainVar); // This call must be below nested func

    // Some more code
}

उदाहरण के लिए JS के साथ तुलना में php में ध्यान देने वाली बात यह है कि नेस्टेड फंक्शन के लिए कॉल करने की आवश्यकता है, यानी नीचे, फ़ंक्शन डिक्लेरेशन (जेएस के साथ फंक्शन कॉल पैरेंट फ़ंक्शन के भीतर कहीं भी हो सकता है)

Question 11

मैंने वास्तव में केवल इस विशेषता का उपयोग किया है जब यह एक प्राथमिक, अधिक स्पष्ट कार्य के अंदर एक छोटे से पुनरावर्ती कार्य को निष्पादित करने के लिए उपयोगी था, लेकिन इसे एक अलग फाइल में स्थानांतरित नहीं करना चाहता था क्योंकि यह एक प्राथमिक प्रक्रिया के व्यवहार के लिए मौलिक था। मुझे लगता है कि ऐसा करने के अन्य "सर्वोत्तम अभ्यास" तरीके हैं, लेकिन मैं यह सुनिश्चित करना चाहता हूं कि मेरे देवता हर बार उस समारोह को मेरे पार्सर को देखें, यह संभव है कि वे वैसे भी संशोधित करें ...

Question 12

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

<?php
function foo($arg1, $arg2) {
    $cacheKey = "foo($arg1, $arg2)";
    if (! getCachedValue($cacheKey)) {
        function _foo($arg1, $arg2) {
            // whatever
            return $result;
        }
        $result = _foo($arg1, $arg2);
        setCachedValue($cacheKey, $result);
    }
    return getCachedValue($cacheKey);
}
?>

Question 13

नेस्टेड फ़ंक्शन उपयोगी हैं यदि आप चाहते हैं कि नेस्टेड फ़ंक्शन एक वैरिएबल का उपयोग करें जो कि पैरेंट फ़ंक्शन के भीतर घोषित किया गया था।

<?php
ParentFunc();
function ParentFunc()
{
  $var = 5;
  function NestedFunc()
  {
    global $var;
    $var = $var + 5;
    return $var;
  };
  echo NestedFunc()."<br>";
  echo NestedFunc()."<br>";
  echo NestedFunc()."<br>";
}
?>