फ़ंक्शन

फ़ंक्शन, स्टेटमेंट का मॉड्यूलर और फिर से इस्तेमाल किया जा सकने वाला ऐसा ब्लॉक होता है जिसका इस्तेमाल संबंधित टास्क, जैसे कि आर्ग्युमेंट के आधार पर वैल्यू कैलकुलेट करना और फिर वैल्यू रिटर्न करना फ़ंक्शन को दिया गया. सभी गैर-प्राइमिटिव वैल्यू की तरह, फ़ंक्शन, ऑब्जेक्ट होते हैं. ये ऐसे यूनीक ऑब्जेक्ट होते हैं जिन्हें कॉल किया जा सकता है कोड चलाने के लिए, तर्क के तौर पर डेटा पास करें, और कोई वैल्यू दिखाएं.

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

function myFunction() {
   console.log( "This is my function." );
};

किसी object की प्रॉपर्टी के तौर पर तय किया गया फ़ंक्शन आम तौर पर इसे "तरीका" कहते हैं. var का इस्तेमाल करके तय किए गए वैरिएबल` की तरह, किसी एनक्लोज़िंग फ़ंक्शन के बाहर किए गए फ़ंक्शन एलान तरीके के तौर पर ग्लोबल ऑब्जेक्ट.

फ़ंक्शन का एलान

फ़ंक्शन की जानकारी (इसे "फ़ंक्शन स्टेटमेंट" या "फ़ंक्शन की परिभाषा" भी कहा जाता है नाम वाला एक फ़ंक्शन बनाता है, जिसे उसके मौजूदा स्कोप में कहीं और शुरू किया जा सकता है. फ़ंक्शन की सूचनाओं में function कीवर्ड के बाद, एक आइडेंटिफ़ायर, ब्रैकेट में दिए गए, कॉमा लगाकर अलग किए गए पैरामीटर की सूची, और ब्लॉक स्टेटमेंट का इस्तेमाल करके "फ़ंक्शन का मुख्य हिस्सा" चुनें. आपको अक्सर ऐसे फ़ंक्शन एलान मिलेंगे जो सेमीकोलन से खत्म होना चाहिए; क्योंकि फ़ंक्शन का एलान एक स्टेटमेंट है. इसके बाद सेमीकोलन ASI की मदद से लगाए जा सकते हैं.

function myFunction() {
   console.log( "This is my function." );
};

myFunction();
> "This is my function."

JavaScript के शुरुआती डिज़ाइन फ़ैसलों पर रोक के रूप में, फ़ंक्शन से जुड़ी जानकारी एक ही लेगसी होइसिंग के तहत आते हैं व्यवहार की जानकारी var के साथ वैरिएबल के रूप में दी जाती है. इसका मतलब है कि फ़ंक्शन की जानकारी अपने दायरे के शीर्ष पर पहुंचा दिया जाता है और नतीजा, भले ही उस दायरे पर स्ट्रिक्ट मोड लागू हो या नहीं:

"use strict";
{
    myFunction();
    function myFunction() {
        console.log( "This is my function." );
    };
}
> "This is my function."

स्ट्रिक्ट मोड के बाहर, फ़ंक्शन एलानों में JavaScript की लेगसी स्कोपिंग का इस्तेमाल किया जाता है बिहेवियर. इसका मतलब है कि फ़ंक्शन का एलान, इसके सबसे पास के दायरे में होता है फ़ंक्शन:

function myFunction() {
    function myNestedFunction() {
        console.log( "This is my nested function." );
    }
    myNestedFunction();
};

myFunction();
> "This is my nested function."

myNestedFunction();
>Uncaught ReferenceError: myNestedFunction is not defined

स्ट्रिक्ट मोड में, फ़ंक्शन की जानकारी उनके सबसे नज़दीक के ब्लॉक के दायरे में आते हैं, जैसा कि इस्तेमाल करके तय किए गए वैरिएबल के साथ किया जाता है let या const:

"use strict";
{
    function myFunction() {
        console.log( "This is my function." );
    };
}

myFunction();
> Uncaught ReferenceError: myFunction is not defined

फ़ंक्शन कॉलिंग

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

function myFunction() {
   console.log( "This is my function." );
};

myFunction;
> myFunction() {
   console.log( "This is my function." );
}

फ़ंक्शन के मुख्य हिस्से के अंदर कोड चलाने के लिए, फ़ंक्शन को कॉल करें (या शुरू करें) इसके लिए, फ़ंक्शन के नाम के बाद, ब्रैकेट के मेल खाने वाले जोड़े का इस्तेमाल करें:

function myFunction() {
    console.log( "My function has been executed." );
}

myFunction();
> "My function has been executed."

फ़ंक्शन की परिभाषा में मौजूद पैरामीटर फ़ंक्शन को कॉल किए जाने पर, फ़ंक्शन के मुख्य हिस्से में पास की जा सकने वाली वैल्यू. जब फ़ंक्शन को कॉल किया जाता है, तो ब्रैकेट में मौजूद वैल्यू, "तर्क" होती हैं (हालांकि, तो आपको "तर्क" दिख सकता है कुछ में आर्ग्युमेंट और पैरामीटर दोनों का वर्णन करने के लिए उपयोग किया जाता है दस्तावेज़):

function myFunction( myParameter ) {
   console.log( `The value is: ${ myParameter }.` );
};

myFunction( "this string" );
> "The value is: this string."

अगर किसी तर्क को शामिल नहीं किया जाता है, तो नतीजे में मिलने वाले पैरामीटर में undefined वैल्यू दी गई है, क्योंकि फ़ंक्शन के मुख्य भाग में पैरामीटर का एलान किया गया है, लेकिन किसी वैल्यू से शुरू नहीं किया जाता:

function myFunction( myParameter ) {
   console.log( `The value is: ${ myParameter }.` );
};

myFunction();
> "The value is: undefined."

पैरामीटर की डिफ़ॉल्ट वैल्यू को उसी तरह शुरू किया जा सकता है जैसा कि वैरिएबल को शुरू करना: असाइनमेंट ऑपरेटर (=) के बाद वैल्यू. अगर आपको बाद में उस फ़ंक्शन के लिए कोई तर्क सेट करता है, तो वह नया मान डिफ़ॉल्ट मान:

function myFunction( myParameter = "omitted" ) {
   console.log( `The value is: ${ myParameter }.` );
};

myFunction( "this string" );
> "The value is: this string."

myFunction();
> "The value is: omitted."

नॉन-ऐरो का मुख्य हिस्सा फ़ंक्शन के पास ज़ीरो-इंडेक्स किए गए डेटा का ऐक्सेस भी होता है, कलेक्शन जैसा arguments ऑब्जेक्ट इसमें आर्ग्युमेंट के तौर पर दी गई कोई भी वैल्यू शामिल हो, चाहे वह फ़ंक्शन हो या नहीं परिभाषा, पैरामीटर के बारे में बताती है:

function myFunction() {
   console.log( arguments );
};

myFunction( 3, true, "My string" );
> Arguments { 0: 3, 1: true, 2: "My string", … }

वैरियाडिक फ़ंक्शन

arguments ऑब्जेक्ट की मदद से, बेसिक वैरियेडिक फ़ंक्शन बनाए जा सकते हैं. इनसे ये काम किए जा सकते हैं आर्ग्युमेंट की वैरिएबल संख्या स्वीकार करें:

function myFunction() {
    let result = "";
    for (let i = 0; i < arguments.length; i++) {
        result += arguments[i] + " - ";
    }
    console.log( result );
};

myFunction( "My first string", "My second string", "my third string" );\
> "My first string - My second string - my third string - "

हालांकि, आधुनिक JavaScript में वैरिडिक फ़ंक्शन का इस्तेमाल बहुत कम ही किया जाता है डेवलपमेंट. ज़्यादा आधुनिक और पढ़ने में आसान तरीकों का इस्तेमाल करना ज़्यादा आम बात है बाकी पैरामीटर सिंटैक्स, यह नाम वाला पैरामीटर बनाता है. यह किसी भी आर्ग्युमेंट वाली कैटगरी के तौर पर शुरू होता है से अलग है:

function myFunction( mySeparator, ...myStrings ) {
  console.log( myStrings.join( mySeparator ) );
};

myFunction( " - ", "My first string", "My second string", "my third string" );
> "My first string - My second string - my third string"

parameter बाइंडिंग के उलट, बाक़ी पैरामीटर सिंटैक्स, ऐरो फ़ंक्शन पैरामीटर के साथ उम्मीद के मुताबिक काम करता है:

function myOuterFunction() {
    let myInnerArrowFunction = ( ...myParams ) => {
        console.log( myParams[ 0 ] );
    }
    myInnerArrowFunction( true );
};

myOuterFunction( false );
> true

let myArrowFunction = ( ...myParams ) => {
    console.log( myParams[ 0 ] );
};

myArrowFunction( true );
> true`
``