फ़ंक्शन

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

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

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 डेवलपमेंट में बहुत कम किया जाता है. ज़्यादा आधुनिक और पढ़ने में आसान rest पैरामीटर सिंटैक्स का इस्तेमाल करना आम बात है. इससे, साफ़ तौर पर बताए गए आर्ग्युमेंट के अलावा, अन्य आर्ग्युमेंट वाले अरे के तौर पर, नाम वाला पैरामीटर बन जाता है.

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`
``