जावास्क्रिप्ट में किसी अन्य फ़ंक्शन के भीतर एक फ़ंक्शन को परिभाषित करें

Question 1

function foo(a) {
    if (/* Some condition */) {
        // perform task 1
        // perform task 3
    }
    else {
        // perform task 2
        // perform task 3
    }
}

मेरे पास एक फ़ंक्शन है जिसकी संरचना उपरोक्त के समान है। मैं कार्य 3 को एक फ़ंक्शन में सार करना चाहता हूं bar(), लेकिन मैं इस फ़ंक्शन की पहुंच को केवल इसके दायरे में सीमित करना चाहता हूं foo(a)।

जो मैं चाहता हूं उसे प्राप्त करने के लिए, निम्नलिखित को बदलना सही है?

function foo(a) {
    function bar() {
        // Perform task 3
    }

    if (/* Some condition */) {
        // Perform task 1
        bar();
    }
    else {
        // Perform task 2
        bar();
    }
}

यदि उपरोक्त सही है, तो क्या bar()हर बार पुनर्निर्धारित foo(a)हो जाता है? (मैं यहाँ सीपीयू संसाधन की बर्बादी के बारे में चिंता कर रहा हूँ।)

Question 2

हां, आपके पास जो है वह सही है। कुछ नोट:

barफ़ंक्शन के लिए प्रत्येक कॉल पर बनाया गया है foo, लेकिन:
- आधुनिक ब्राउज़रों पर यह एक बहुत तेज़ प्रक्रिया है। (कुछ इंजन अच्छी तरह से केवल एक बार इसके लिए कोड संकलित कर सकते हैं , और फिर उस कोड को हर बार एक अलग संदर्भ के साथ पुन: उपयोग कर सकते हैं; Google का V8 इंजन [क्रोम और अन्य जगहों पर] ज्यादातर मामलों में यही करता है।)
- और क्या barकरता है पर निर्भर करते हुए , कुछ इंजन यह निर्धारित कर सकते हैं कि वे इसे पूरी तरह से "इनलाइन" कर सकते हैं, जिससे फ़ंक्शन कॉल पूरी तरह से समाप्त हो जाएगी। V8 ऐसा करता है, और मुझे यकीन है कि यह एकमात्र इंजन नहीं है जो करता है। स्वाभाविक रूप से वे केवल ऐसा कर सकते हैं यदि यह कोड के व्यवहार को नहीं बदलता है।
barहर बार बनाए जाने पर प्रदर्शन प्रभाव, यदि कोई हो, तो जावास्क्रिप्ट इंजनों के बीच व्यापक रूप से भिन्न होगा। यदि barयह तुच्छ है, तो यह अवांछनीय से काफी छोटा हो जाएगा। यदि आप fooएक पंक्ति (उदाहरण के लिए, एक mousemoveहैंडलर से) में हजारों बार कॉल नहीं कर रहे हैं , तो मुझे इसकी चिंता नहीं होगी। यहां तक कि अगर तुम हो, मैं केवल इसके बारे में चिंता करूंगा अगर मुझे धीमी इंजन पर कोई समस्या दिखाई दी। यहां DOM ऑपरेशंस से जुड़ा एक टेस्ट केस है , जो बताता है कि एक प्रभाव है, लेकिन एक तुच्छ (शायद DOM सामान द्वारा धोया गया)। यहाँ शुद्ध अभिकलन करने वाला एक परीक्षण मामला है जो बहुत अधिक प्रभाव दिखाता है, लेकिन स्पष्ट रूप से, हम सूक्ष्म सेकंड के अंतर की बात कर रहे हैं क्योंकि यहां तक कि सूक्ष्म ले जाने वाली चीज़ पर 92% की वृद्धिसेकंड होने के लिए अभी भी बहुत, बहुत तेज है। जब तक / जब तक आपने वास्तविक-विश्व प्रभाव नहीं देखा, तब तक चिंता की कोई बात नहीं है।
barकेवल फ़ंक्शन के भीतर से ही पहुँचा जा सकेगा, और उस फ़ंक्शन के लिए सभी चर और तर्कों तक पहुंच होगी। यह इसे बहुत आसान पैटर्न बनाता है।
ध्यान दें कि क्योंकि आपने फ़ंक्शन डिक्लेरेशन का उपयोग किया है , इससे कोई फर्क नहीं पड़ता कि आपने डिक्लेरेशन (टॉप, बॉटम या मिडल) को कहाँ तक रखा है - जब तक यह फंक्शन के टॉप लेवल पर है, न कि एक फ्लो कंट्रोल स्टेटमेंट के अंदर, जो है एक सिंटैक्स त्रुटि), यह चरण-वार कोड की पहली पंक्ति चलाने से पहले परिभाषित हो जाता है।

Question 3

यह वही है जिसके लिए क्लोजर हैं।

var foo = (function () {
  function bar() {
    // perform task 3
  };

  function innerfoo (a) { 
    if (/* some cond */ ) {
      // perform task 1
      bar();
    }
    else {
      // perform task 2
      bar();
    }
  }
  return innerfoo;
})();

इनरफू (एक बंद) बार के लिए एक संदर्भ रखता है और केवल इनरफू का एक संदर्भ एक अनाम फ़ंक्शन से वापस किया जाता है जिसे केवल एक बार बंद करने के लिए कहा जाता है।

बार इस तरह से बाहर से सुलभ नहीं है।

Question 4

var foo = (function () {
    var bar = function () {
        // perform task 3
    }
    return function (a) {

        if (/*some condition*/) {
            // perform task 1
            bar();
        }
        else {
            // perform task 2
            bar();
        }
    };
}());

बंद होने की गुंजाइश बनी रहती है bar() समाहित , नए कार्य को स्व-निष्पादित अनाम फ़ंक्शन से वापस करना अधिक दृश्यमान गुंजाइश सेट करता है foo()। अनाम स्व-क्रियान्वयन फ़ंक्शन ठीक एक बार चलाया जाता है, इसलिए केवल एक bar()उदाहरण है, और प्रत्येक निष्पादन foo()इसका उपयोग करेगा।

Question 5

हां, यह ठीक काम करता है।

हर बार जब आप बाहरी फ़ंक्शन में प्रवेश करते हैं तो आंतरिक फ़ंक्शन को फिर से बनाया नहीं जाता है, लेकिन इसे फिर से असाइन किया जाता है।

यदि आप इस कोड का परीक्षण करते हैं:

function test() {

    function demo() { alert('1'); }

    demo();
    demo = function() { alert('2'); };
    demo();

}

test();
test();

यह दिखा देंगे 1, 2, 1, 2, नहीं 1, 2, 2, 2।

Question 6

मैंने नेस्टेड बनाम नॉन-नेस्टेड और फ़ंक्शन एक्सप्रेशंस बनाम फ़ंक्शन घोषणाओं का परीक्षण करने के लिए एक jsperf बनाया, और मुझे यह देखकर आश्चर्य हुआ कि नेस्टेड परीक्षण मामलों ने नॉन-नेस्टेड की तुलना में 20 गुना तेजी से प्रदर्शन किया। (मुझे या तो विपरीत या नगण्य अंतर की आशंका है)।

https://jsperf.com/nested-functions-vs-not-nested-2/1

यह Chrome 76, macOS पर है।