कार्यों के अंदर स्कोप कॉलिंग कार्यों

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

कार्य:

एक फ़ंक्शन योग बनाएं जो इस तरह काम करेगा: sum (a) (b) = a + b और किसी भी संख्या को ब्रैकेट स्वीकार करता है। उदाहरण:

sum(1)(2) == 3
sum(5)(-1)(2) == 6

समाधान:

function sum(a) {

    var sum = a;

    function f(b){
        sum += b;
        return f;
    }

    f.toString = function() { return sum };

    return f;         //line 12
}

alert( sum(1)(2) );  //3e

स्पष्टीकरण:

sum (1) को कॉल करने योग्य sum (1) (2) बनाने के लिए, इसे एक फ़ंक्शन वापस करना होगा। फ़ंक्शन को या तो valueOf वाले नंबर पर कॉल या रूपांतरित किया जा सकता है। समाधान वास्तव में आत्म व्याख्यात्मक है:

मेरी व्याख्या:

यह f function f (b) में दायरे में लौटा, जो लाइन 02 - 12 से है। f f.toString में, वर्तमान में f function (b) से लौटाया गया है अगला वापसी f उस कार्यक्षेत्र में वापस आता है जो फ़ंक्शन के बाहर है sum (a)

समस्या:

मैं समझ नहीं पा रहा हूं, जहां मुझे अलग-अलग सोचने की ज़रूरत है, क्योंकि जैसा मैंने उपरोक्त वर्णित किया है, फ़ंक्शन को फिर से नहीं कहा जाएगा, इसलिए कोड का हिस्सा कहां है, जो 'कई कोष्ठक' संभव बनाता है?

इसके अलावा, क्या मैंने सही ढंग से यह माना कि f s वापस आये हैं? अगर कोई कुछ स्पष्टीकरण देगा तो अच्छा होगा।

0
जोड़ा लेखक Bergi, स्रोत
आपका मतलब क्या है " अगला वापसी f उस कार्यक्षेत्र में वापस आता है जो फ़ंक्शन योग (ए) " के बाहर है?
जोड़ा लेखक Bergi, स्रोत
एक पैरामीटर के साथ sum को कॉल करना एक फ़ंक्शन देता है जिसे अगले पैरामीटर के साथ बुलाया जा सकता है। इसे "करी" कहा जाता है; एक तर्क के साथ एक समारोह को बुलाकर जब तक सभी तर्कों का मूल्यांकन नहीं किया जाता है, तो परिणाम वापस कर दें।
जोड़ा लेखक elclanrs, स्रोत
@ बर्गि मुझे गलत से साफ़ करने के लिए धन्यवाद। करीना एक अलग जानवर को पूरी तरह से जोड़ता है। एक अद्भुत सवाल, यह पूछने के लिए धन्यवाद, यह रसदार जानकारी के साथ उत्तर का एक बड़ा सेट बना देगा
जोड़ा लेखक hanzo2001, स्रोत

6 उत्तर

चलो लाइन द्वारा फंक्शन लाइन के माध्यम से कदम:

function sum(a) {

यह हिस्सा सुंदर आत्म-व्याख्यात्मक है; हमारे पास sum नामक फ़ंक्शन है जो एक तर्क a स्वीकार करता है।

    var sum = a

यहां हमारे पास एक स्थानीय चर है जिसे sum कहा जाता है जो कि पारित तर्क के मान पर सेट होता है।

    function f(b) {
        sum += b
        return f
    }

यह f नामक एक आंतरिक फ़ंक्शन है जो b नामक एक तर्क स्वीकार करता है। यह b को बाहरी स्कोप से sum के मान में जोड़ा जाता है (यानी, फ़ंक्शन के दायरे के अंदर जिसे राशि )। उसके बाद, फ़ंक्शन स्वयं लौटाता है।

    f.toString = function() { return sum }

This is the fun part! When you normally console.log a function, it will just spit out the function's source. Here we are redefining the toString method to instead be a function that spits out the value of sum. This is why you end up seeing the running total that is displayed instead of the function's source even though what you are returning is still a function.

अंत में हमारे पास है:

    return f

इसलिए आपके पास मूल रूप से एक फ़ंक्शन sum है, जो फ़ंक्शन लौटाता है जो स्वयं लौटाता है । फ़ंक्शन sum मूल रूप से सबकुछ सेट करता है, लेकिन sum (3) को कॉल करने के बाद, फिर आप f के साथ काम करते हैं, जिसे आप बार-बार कॉल करते हैं।

तो पहली बार जब आप sum को कॉल करते हैं, तो आप अनिवार्य रूप से इस फ़ंक्शन को वापस ले लेंगे:

function f(b) {
   sum += b; //value of sum is 3
   return f;
}

इस संदर्भ में, sum का मान a का मान होगा जिसे आपने फ़ंक्शन sum की प्रारंभिक कॉल में पारित किया था। हालांकि, f के toString को फिर से परिभाषित किया गया है, इसलिए आप केवल 3 मान देखते हैं। तो मान लें कि आप sum (3) (4) करते हैं।

आप पहले की तरह वापस आते हैं:

function f(b) {
   sum += b; //value of sum is 3
   return f;
}

लेकिन फिर आप वास्तव में 4 (मूल रूप से f (4) ) के तर्क के साथ f को कॉल कर रहे हैं। चूंकि f एक आंतरिक कार्य है, इसलिए इसके मूल कार्य के दायरे में पूर्ण पहुंच है। यह मूल कार्य ( sum ) चल रहा कुल को sum नामक चर में बनाए रखता है, जो f तक पहुंच योग्य है। तो जब आप अब f (4) पर कॉल करते हैं, तो आपके पास b 4 और sum पर सेट होता है जिसका मूल्य होता है 3 :

function f(b) { //b is 4
   sum += b; //value of sum is 3 + 4, which is 7
   return f;
}

तो प्रत्येक बाद की जोड़ी कोष्ठक के साथ आप वही f पर चलने वाली कॉल को बनाए रखने वाले दोबारा कॉल कर रहे हैं।

एक और तरीका sum को एक प्रकार के फैक्ट्री के रूप में सोचना है जो आपको अलग f 'दे सकता है, जिनमें से सभी अपने स्वयं के चलने वाली लम्बाई रखते हैं (मूल रूप से accumulators की तरह व्यवहार):

var firstSum = sum(4);
var secondSum = sum(2);

firstSum(5); //equivalent to sum(4)(5) returns 9
secondSum(2); //equivalent to sum(2)(2) returns 4
0
जोड़ा

फ़ंक्शन sum फ़ंक्शन देता है, जिसे हम f के रूप में संदर्भित करते हैं।

फ़ंक्शन f फ़ंक्शन भी देता है: वास्तव में, फ़ंक्शन f स्वयं लौटाता है।

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

चूंकि f स्वयं लौटाता है, इसलिए आप बार-बार कॉल के साथ f चेन कर सकते हैं:

var this_is_f = sum(1);
var same_f_again = this_is_f(2);
var f_a_third_time = same_f_again(3);

या केवल:

sum(1)(2)(3);

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

sum पर प्रत्येक कॉल एक नए स्थानीय f को एक नए स्थानीय sum के साथ अपने दायरे में बनाता है (यहां, मेरा मतलब है स्थानीय sum sum नामक फ़ंक्शन की पहली पंक्ति पर परिभाषित किया गया है)। हालांकि, फ़ंक्शन को कॉल करना sum किसी पुराने f को क्लॉबर नहीं करता है, क्योंकि sum पर प्रत्येक कॉल एक नया f (और किसी अन्य f s के बारे में कुछ भी नहीं जानता है जो पूर्व कॉल पर sum पर बनाया गया है)। इस तरह, आप कई लम्बे चल सकते हैं:

var first_tally = sum(1)(2);  //first: 3
var second tally = sum(4)(5); //second: 9
first_tally(3);  //first: 6
second_tally(6); //second: 15

किसी भी समय एक सार्थक परिणाम देखने में सक्षम होने का कारण यह है कि f आपको अपना कोड कोड दिखाने के बजाय sum के मान पर निर्भर करता है।

0
जोड़ा
हैलो, उत्तर के लिए धन्यवाद। समारोह एफ रिटर्न एफ। लेकिन कहाँ से? क्या "शामिल" एफ है? या अलग: returnd f कहां जा रहा है ... कोई var है जो इसे सौंपा गया है। सेवा मेरे। मेरु
जोड़ा लेखक Meru, स्रोत
@ मेरू यह वर्तमान में कहीं नहीं जा रहा है ... लेकिन आप इस परेशान वास्तविकता से अवगत थे, है ना? मुझे लगता है, आप बस स्वीकार नहीं करना चाहते थे: डी
जोड़ा लेखक leaf, स्रोत
@ मेरू ठीक है, मैं मजाक कर रहा हूँ। f समानांतर ब्रह्मांड में रहता है, जहां कोई भी नहीं जा सकता है लेकिन f , sum फ़ंक्शन को कॉल करने के समय बनाया गया है (जो जैसा है एक तरह से बड़ा धमाका)। फिर, var लिखने के बाद function f लिखने की आवश्यकता नहीं है, वही प्रभाव उत्पन्न करता है।
जोड़ा लेखक leaf, स्रोत

यदि आप यह कोड लेते हैं और इसे न्यूनतम रूप से सरल बनाते हैं तो मुझे समझना आसान होगा। एक फ़ंक्शन जोड़ें लें जो केवल 2 संख्याओं का योग करता है:

function add(x,y) {
  return x + y;
}

उपर्युक्त "सामान्य" फ़ंक्शन है। यदि आप सभी तर्कों को पारित नहीं करते हैं तो आपको अप्रत्याशित परिणाम मिलेंगे।

अब, यदि आप कोई फ़ंक्शन चाहते हैं जो किसी भी संख्या में 2 जोड़ता है, तो आप आंशिक रूप से add पर एक तर्क लागू कर सकते हैं, उदाहरण के लिए:

function add2(x) {
  return add(2, x);
}

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

function add(x) {
  return function(y) {
    return x + y;
  }
}

अब आप फंक्शन add को कंट्री करके add2 फ़ंक्शन बना सकते हैं:

var add2 = add(2);
add2(1); //=> 3

सामान्य कार्य और करीबी व्यक्ति के बराबर गणना होती है जहां:

add(1, 2) === add(1)(2)

यह "कई कोष्ठक" संभव बनाता है।

जावास्क्रिप्ट में "गुंजाइश" और "बंद" कार्यों को संदर्भित करता है लेकिन वे अलग-अलग अवधारणाएं हैं। एक "गुंजाइश" आपके चर के पहुंच/गोपनीयता को निर्धारित करता है जबकि "बंद" आपको कोड को समाहित करने और इसे चारों ओर ले जाने देता है। वैरिएबल x के ऊपर क्यूरिड फ़ंक्शन में बंद होने के माध्यम से स्मृति में रखा जाता है क्योंकि इसे वापस फ़ंक्शन ऑब्जेक्ट के अंदर संदर्भित किया जाता है।

"करीइंग" की एक विशेष सीमा यह है कि आपके पास गतिशील धैर्य के कार्य नहीं हो सकते हैं; तर्कों की संख्या तय की जानी चाहिए। आपके द्वारा पोस्ट किए गए कोड में यह मामला नहीं है जहां आपका sum फ़ंक्शन पिछले योग में अनिश्चित काल तक एक नया नंबर जोड़ने में सक्षम होना चाहिए।

इसी प्रकार "करीकरण" के लिए "जेनरेटर" का विचार है; आलसी गणना के मॉडल अनुक्रमों के लिए एक पैटर्न, इस मामले में मांग पर पिछले योग में केवल एक संख्या जोड़ना।

function sum(a) {//begin closure
  var sum = a;//kept in memory...
  function f(b) {
    sum += b; //...because you use it here
    return f;
  }
  f.toString = function() { return sum };
  return f;
}//end closure

अपने कोड को व्यक्त करने के लिए एक अलग (शायद अधिक स्पष्ट) तरीका कंप्यूशन को चेन करने के लिए ऑब्जेक्ट को वापस करना होगा, जहां आप या तो पिछले योग में एक नया नंबर जोड़ सकते हैं, या अब तक कुल योग प्राप्त कर सकते हैं:

function add(a) {
  var sum = a;
  return {
    plus: function(b) {
      sum += b;
      return this;
    },
    sum: function() {
      return sum;
    }
  }
}

add(1).plus(2).plus(3).sum(); //=> 6

आपके कोड में लौटा हुआ कार्य f प्लस और toString के रूप में कार्य करता है sum जो मान पुनर्प्राप्त करता है।

0
जोड़ा
जवाब के लिए धन्यवाद। आपकी कॉल-चेन में "sum ()" केवल एक बार बुलाया जाता है। इसका मतलब यह कैसे था: क्या यह फ़ंक्शन-कॉल "आप" लिखता है, या कोड इसे निष्पादित करता है? अगर यह आदेश है कि इसे "योग (1) (2) (3)" पर कॉल करने पर, निष्पादित किया गया है, तो मेरे पास सवाल है: क्यों राशि() केवल एक बार बुलाई जाती है?
जोड़ा लेखक Meru, स्रोत

चेनिंग

नोटिस जो:

  • The 4 occurences of f refer to the same function.
  • The first pair of brackets calls sum while the others call f.
  • sum returns f and f returns itself, in other words, whenever you write (), you're returning the same f function.

संक्षेप में:

sum(0)      //sum(0) -> f
sum(0)(1)   //sum(0), f(1) -> f
sum(0)(1)(2)//sum(0), f(1), f(2) -> f

हठ

ऐसा कहा जा रहा है, मुख्य सवाल यह है कि योग की स्थिति उन फ़ंक्शन कॉल के साथ कैसे जारी रह सकती है? यह वह जगह है जहां यह प्रसिद्ध "बंद" चीज़ आती है। मैं विवरण में इस अवधारणा के बारे में बात नहीं करने जा रहा हूं, Google बहुत बेहतर मदद कर सकता है । कुछ शब्दों में, यह f और sum चर के बीच संबंधों के बारे में है। दरअसल, इस पल से वे जीवन में आते हैं, पहले फंक्शन कॉल के लिए धन्यवाद, वे अपने शेष अस्तित्व के लिए एक ही निजी संदर्भ साझा करेंगे। नतीजतन, प्रत्येक आगामी कॉल में मौजूदा sum चर को f के माध्यम से संशोधित करने में शामिल होता है:

sum(0)      //var sum = 0
sum(0)(1)   //var sum = 0, sum += 1
sum(0)(1)(2)//var sum = 0, sum += 1, sum += 2

परिणाम

अंत में, f के स्थान पर एक स्ट्रिंग की अपेक्षा होने पर toString स्वचालित रूप से कॉल किया जाता है:

typeof(sum(1)(1))     //typeof(f) -> "function"
typeof(sum(1)(1) + '')//typeof(f + '') -> typeof('2' + '') -> "string"
                                                    ^
                                                    toString was called

ध्यान दें कि आप valueOf का भी उपयोग कर सकते हैं। यह थोड़ा और संगत हो सकता है क्योंकि फ़ंक्शन की घोषणा पहले से ही toString विधि के संस्करण का मालिक है।

बोनस

That's it, hope this explanation was clear enough. As a conclusion, here is a similar approach (to get the final परिणाम, just put an empty pair of brackets at the end of the queue):

function sum(a) {
    return function (b) {
        return arguments.length ? sum(a+b) : a;
    };
};

sum(1)(1)(1)();//3
0
जोड़ा
  1. Line 01-13 defines the function sum within the global scope.
  2. Line 15 calls sum and changes scope to inside the function.
    1. The variables a and sum and the closure function f are all defined in the function's scope - with the sum variable hiding the function definition from the global scope.
    2. I'll skip over the toString bit here as its not important till later (when it gets very important).
    3. The function sum finally returns a reference to the closure function f to the global scope as an anonymous function (since f can only be referenced by name from within its containing function's scope).
  3. Back to line 15 - sum(1)(2) is the same as (sum(1))(2) and since sum(1) returns f then this can be reduced to (f)(2) or, more simply, f(2).
    1. Calling f(2) adds 2 to sum - sum is defined in two scopes: as a function in the global scope; and as a variable (currently assigned the value of 1) within that function which hides the definition from the global scope - so, in f, the sum variable is set to 1+2=3.
    2. Finally, in f, the function returns itself.
  4. Back, again, to line 15 - f(2) returns f (although the named function f cannot be referenced in the global scope and, again , is treated as an anonymous function)
  5. alert() is processed and the anonymous function (referred to as f) is converted to a string to be alerted; normally when alert() is called on a function it will display the source for the function (try commenting out Line 10 to see this). However, since f has a toString method (Line 10) then this is invoked and the value of sum (as defined in the function containing f) is returned and 3 is alerted.
0
जोड़ा
@ MT0 यह एकमात्र उत्तर है जिसे मैं आसानी से समझता हूं। मुझे नहीं पता कि किसी ने आपके जवाब को अपवित्र क्यों नहीं दिया। धन्यवाद!
जोड़ा लेखक zwlayer, स्रोत
@ एमटीओ, धन्यवाद। इसके साथ - एक कॉल 'योग (1) (2) (3)' कॉलिंग के साथ होगा: योग (1)> f> f (2)> f> f (3)> लौटने पर वापस लौटना, और क्योंकि कोई अन्य नहीं कंस्ट्रैसिस अब और हैं> f.toString() कहा जाता है। क्या ये सही है?
जोड़ा लेखक Meru, स्रोत
तो, "f.toString" को केवल एक बार बुलाया जाता है, जबकि "फ़ंक्शन एफ (बी)" दो बार कैल्ड होता है (कॉलिंग में दो पैरामीटर के मामले में)? "एफ" का पैरामीटर, "बी", हमेशा उस कॉलम का पैरामीटर होता है: योग (1) (2)?
जोड़ा लेखक Meru, स्रोत
नहीं - <कोड> अलर्ट (योग (1) (2)) चेतावनी (((योग (1)) (2)) .toString ()) जैसा हो सकता है आदेश में मूल्यांकन किया जाना चाहिए: sum (1) को f लौटाया जाता है, फिर f (2) को f और अंत में f.toString() कहा जाता है; तो sum() , f() और f.toString() सभी को केवल एक बार बुलाया जाता है।
जोड़ा लेखक MT0, स्रोत
sum (1) जो f > f (2) लौटाता है जो f > अलर्ट (f ) जो स्पष्ट रूप से अलर्ट (f.toString ()) और f.toString() लौटाता है 3 में परिवर्तित किया जाता है।
जोड़ा लेखक MT0, स्रोत

यहां 3 अवधारणाएं खेली जा रही हैं

  • closures (no scope).
  • functions are first class OBJECTS in JavaScript (allows for chaining f(a)(b)(c)). There's no need to save a handle to the function to call it later.

मैं आपको एक रन-डाउन दूंगा और फिर बाद में कुछ अतिरिक्त स्पष्टीकरण जोड़ूंगा

function sum(a) {
 //when sum is called, sumHolder is created
  var sumHolder = a;
 //the function f is created and holds sumHolder (a closure on the parent environment)
  function f(b) {
   //do the addition
    sumHolder += b;
   //return a FUNCTION
    return f;
  }
 //change the functions default toString method (another closure)
  f.toString = function() {return sumHolder;}
 //return a FUNCTION
  return f
}
/*
 * ok let's explain this piece by piece
 * 
 * you call sum with a parameter
 *  - parameter is saved into sumHolder
 *  - a function is returned
 * 
 * you call the returned function f with another parameter
 * EXPLANATION: { sum(a) } returns f, so let's call f as this => {...}()
 *  - this private (priviledged) function adds whatever it's been passed
 *  - returns itself for re-execution, like a chain
 * 
 * when it all ends {{{{}(a)}(b)}(c)} the remainder is a FUNCTION OBJECT
 * this remainder is special in that it's toString() method has been changed
 *  so we can attempt to cast (juggle) it to string for (loose) comparison
 * 
 */

बंद होने के पीछे की अवधारणा को समझना काफी आसान है, लेकिन यह एप्लिकेशन आपके सिर स्पिन को तब तक बना देता है जब तक आप इस विचार में उपयोग न करें कि जावास्क्रिप्ट में कोई फ़ंक्शन स्कोप नहीं है , बंद है और ये वास्तव में शक्तिशाली critters हैं

// this anonymous function has access to the global environment and window object
(function()
  {// start this context
    var manyVars, anotherFunc;
    function someFunc() {
     //has access to manyVars and anotherFunc
     //creates its own context
    };
    anotherFunc = function() {
     //has access to the same ENVIRONMENT
     //creates its own context
    };
  }// whatever is in these keys is context that is not destroyed and
 // will exist within other functions declared inside
 // those functions have closure on their parent's environment
 // and each one generates a new context
)();

कार्य प्रथम श्रेणी की वस्तुएं हैं। इसका क्या मतलब है? मुझे यकीन नहीं है कि मुझे कुछ और उदाहरणों के साथ समझाएं:

// how about calling an anonymous function just as its created
// *cant do the next line due to a language constraint
// function(){}()
// how about a set of parens, this way the word "function" is not the first expression
(function(){}());
// the function was created, called and forgotten
// but the closure inside MAY STILL EXIST
function whatDoIReturn() {
  return function (){alert('this is legal');return 'somevalue';}();// and executed
}// returns 'somevalue'

शब्द के लिए यह शब्द मत लो। अन्य लोगों के कोड की तलाश करें, क्रॉकफोर्ड देखें और आने वाले किसी भी और सभी प्रश्न पूछें

0
जोड़ा
@ हांजो 2001: तो आपका मतलब है: "केवल फ़ंक्शन स्कोप है, कोई ब्लॉक स्कोप नहीं है (अन्य भाषाओं में)"
जोड़ा लेखक Bergi, स्रोत
बीटीडब्ल्यू, फंक्शंस फ़ंक्शन फ़ंक्शन को करीइंग नहीं कहा जाता है, यह केवल कार्यात्मक प्रोग्रामिंग है। देखें करीबी वास्तव में यह है, और ध्यान दें कि यह वास्तव में है केवल परिभाषित संख्या के पैरामीटर के साथ कार्यों के लिए परिभाषित किया गया है।
जोड़ा लेखक Bergi, स्रोत
बेशक वहाँ कार्यक्षेत्र है! उससे तुम्हारा मतलब क्या था? साथ ही, " क्रॉकफ़ोर्ड " कैसे जांचें?
जोड़ा लेखक Bergi, स्रोत
@ बर्गि जब लोग अन्य भाषाओं से आते हैं और एक फंक्शन परिभाषा में {} (ब्लॉक) देखते हैं तो वे गलती से सोचते हैं कि स्कोप सी, PHP <5.3, जावा ... जैसा बिल्कुल ठीक काम करता है लेकिन तथ्य यह है कि यह नहीं करता है। फ़ंक्शन ब्रैकेट के अंदर की जगह एक विशाल स्कोप बनाता है जो सहेजा जाएगा और इसके अंदर परिभाषित अन्य कार्यों को पारित किया जाएगा। कुछ लोग जावा में निजी सदस्यों की तरह दिखने के द्वारा इन छिपा स्कॉप्स के साथ खेलना पसंद करते हैं। क्रॉकफोर्ड के लिए: javascript.crockford.com । उनके पास ऐसे वीडिय
जोड़ा लेखक hanzo2001, स्रोत
@ बर्गि हाँ, यह इस तरह की आवाज होगी, लेकिन मैं इसे बदल दूंगा "कार्य विशेष क्षेत्रों को बनाते हैं जो बंद करने के निर्माण की अनुमति देते हैं, उन्हें फ़ंक्शन स्कोप के रूप में नहीं मानते हैं जो आपको अन्य भाषाओं में मिलता है, बंद करना अधिक शक्तिशाली और कम क्षमाशील है "
जोड़ा लेखक hanzo2001, स्रोत
करीबी के मामले पर @ बर्गि आप बिल्कुल सही हैं। मैं उस विषय पर सभी सामग्री मिटा दूंगा
जोड़ा लेखक hanzo2001, स्रोत