फ़ंक्शन एक्सप्रेशन

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

const myVariable = function() { };

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

const myVariable = function() {
    console.log( "This is my function." );
};

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

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

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

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

हालांकि, फ़ंक्शन एलान के उलट, नाम वाला फ़ंक्शन एक्सप्रेशन इन्हें फ़ंक्शन के नाम से ही ऐक्सेस किया जाता है:

const myVariable = function myFunction() {
  console.log( `I'm a ${ typeof myFunction }.`);
};

typeof myFunction;
> "undefined"

typeof myVariable;
> "function"

myVariable();
> "I'm a function."

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

const myVariable = function myFunction() {
    console.log( "One second elapsed." );
    setTimeout( myFunction, 1000 );
};

setTimeout( myVariable, 1000 );
> "One second elapsed."
> "One second elapsed."
> "One second elapsed."
…

ऐरो फ़ंक्शन एक्सप्रेशन

ऐरो फ़ंक्शन एक्सप्रेशन (इन्हें अक्सर "ऐरो फ़ंक्शन" कहा जाता है या आम तौर पर, "लैम्डा" भी कहा जाता है) फ़ंक्शन") को ES6 में इसलिए शामिल किया गया था, ताकि इसे बनाने के लिए एक छोटा सिंटैक्स उपलब्ध कराया जा सके कुछ खास व्यवहार के साथ, बिना नाम वाले फ़ंक्शन एक्सप्रेशन.

जहां भी एक्सप्रेशन की उम्मीद हो वहां ऐरो फ़ंक्शन बनाया जा सकता है उदाहरण के लिए, किसी वैरिएबल को असाइन की गई वैल्यू. अपने सामान्य रूप में, एक तीर फ़ंक्शन, मेल खाने वाले ऐसे ब्रैकेट से बना होता है जिसमें शून्य या उससे ज़्यादा होते हैं पैरामीटर, जिसमें एक बराबर का चिह्न और 'इससे ज़्यादा' वर्ण वाला तीर का निशान बना होता है (=>) और फ़ंक्शन मुख्य हिस्से वाले मेल खाने वाले कर्ली ब्रैकेट का एक जोड़ा:

const myFunction = () => {};

कुछ स्थितियों में, सिंटैक्स को और भी छोटा किया जा सकता है. अगर आप: सिर्फ़ एक पैरामीटर का इस्तेमाल करके, शुरुआती ब्रैकेट को छोड़ा जा सकता है:

const myFunction = myParameter => {};

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

const myFunction = () => 2 + 2

myFunction()
> 4

ऐरो फ़ंक्शन इस मामले में यूनीक होते हैं कि उनके पास arguments या this वैल्यू के लिए अपना कॉन्टेक्स्ट नहीं होता. इसके बजाय, वे दोनों को इनहेरिट करते हैं ऐरो फ़ंक्शन से लेक्सिकली एनक्लोज़िंग एनवायरमेंट, जो सबसे नज़दीक enक्लोज़िंग फ़ंक्शन है जो ऐसे संदर्भ उपलब्ध कराता है.

function myParentFunction() {
    this.myProperty = true;
    let myFunction = () => {
            console.log( this );
    }
    myFunction();
};

let myInstance = new myParentFunction();
> Object { myProperty: true }

कॉल ऐरो फ़ंक्शन

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

function myFunction() {
    let myArrowFunction = () => {
            console.log( arguments[ 0 ] );
    }
    myArrowFunction( true );
};

myFunction( false );
> false

इस उदाहरण में, आर्ग्युमेंट false के साथ कॉल किया गया आउटर फ़ंक्शन, आर्ग्युमेंट true के साथ इनर ऐरो फ़ंक्शन को कॉल करता है. ऐरो फ़ंक्शन के अंदर मौजूद arguments ऑब्जेक्ट, बाहरी फ़ंक्शन में बाइंडिंग पर रिज़ॉल्व होता है. इसलिए, अंदरूनी फ़ंक्शन, बाहरी फ़ंक्शन के false को लॉग करता है.

अगर पैरंट कॉन्टेक्स्ट से इनहेरिट करने के लिए कोई arguments ऑब्जेक्ट नहीं है, तो ऐरो फ़ंक्शन का arguments ऑब्जेक्ट तय नहीं किया गया है, और इसे ऐक्सेस करने की कोशिश करने से गड़बड़ी:

let myArrowFunction = () => {
    console.log(arguments);
};
myArrowFunction( true );
> Uncaught ReferenceError: arguments is not defined

तुरंत लागू होने वाले फ़ंक्शन एक्सप्रेशन (IIFE)

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

(function() {
    console.log( "IIFE.")
    }
)();
> "IIFE."

(function() {
    console.log( "IIFE.")
    }
());
> "IIFE."

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

हालांकि, जब आपका IIFE एक ऐरो फ़ंक्शन होता है, तो इसमें अंतर होता है. इस मामले में, फ़ंक्शन को कॉल करने के लिए इस्तेमाल किए गए ब्रैकेट, ग्रुपिंग ऑपरेटर के बाहर होने चाहिए, क्योंकि ऐरो फ़ंक्शन अपने-आप कोई एक्सप्रेशन नहीं होता. हालांकि, इसे ऐसे कॉन्टेक्स्ट में बनाया जाना चाहिए जहां एक्सप्रेशन की उम्मीद की जाती है. ग्रुपिंग ऑपरेटर के स्कोप में से ऐरो फ़ंक्शन को कॉल करने का मतलब है कि किसी ऐसे ऐरो फ़ंक्शन को कॉल करना जो अब तक किसी एक्सप्रेशन के संदर्भ में नहीं बनाया गया है:

( () => {
    console.log( "IIFE." );
}() );
> Uncaught SyntaxError: missing ) in parenthetical

ग्रुपिंग ऑपरेटर एक्सप्रेशन की उम्मीद करते हैं, इसलिए ऐरो फ़ंक्शन के अंदर उन्हें परिभाषित किया गया है, जिससे उन्हें फ़ॉलो करने वाले ब्रैकेट को ग्रुप किए गए एक्सप्रेशन:

( () => {
    console.log( "IIFE." );
} )();
> "IIFE."

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

देखें कि आपको कितना समझ आया है