JavaScript
एरो फ़ंक्शंस

परिचय

वाक्य - विन्यास

• x => y // इंप्लिमेंट रिटर्न

• x => {वापसी y} // स्पष्ट वापसी

• (x, y, z) => {...} // एकाधिक तर्क

• async () => {...} // Async तीर फ़ंक्शन

• (() => {...}) () // तत्काल-इनवॉल्ड फंक्शन एक्सप्रेशन

• const myFunc = x

  => x * 2 // तीर से पहले एक लाइन ब्रेक एक 'अप्रत्याशित टोकन' त्रुटि को फेंक देगा

• const myFunc = x =>

  x * 2 // तीर के बाद एक लाइन ब्रेक एक वैध सिंटैक्स है

टिप्पणियों

परिचय

जावास्क्रिप्ट में, फ़ंक्शन को "तीर" ( => ) सिंटैक्स का उपयोग करके गुमनाम रूप से परिभाषित किया जा सकता है, जिसे कभी-कभी कॉमन लिस्प समानता के कारण लैंबडा अभिव्यक्ति के रूप में संदर्भित किया जाता है।

तीर फ़ंक्शन का सबसे सरल रूप => के बाईं ओर इसके तर्क हैं और दाईं ओर वापसी मूल्य है:

item => item + 1 // -> function(item){return item + 1}

इस फ़ंक्शन को अभिव्यक्ति का तर्क देकर तुरंत लागू किया जा सकता है:

(item => item + 1)(41) // -> 42

यदि कोई तीर फ़ंक्शन एकल पैरामीटर लेता है, तो उस पैरामीटर के आसपास कोष्ठक वैकल्पिक होते हैं। उदाहरण के लिए, निम्न अभिव्यक्तियाँ एक ही प्रकार के फ़ंक्शन को निरंतर चर में प्रदान करती हैं :

const foo = bar => bar + 1;
const bar = (baz) => baz + 1;

हालाँकि, यदि तीर फ़ंक्शन कोई पैरामीटर नहीं लेता है, या एक से अधिक पैरामीटर है, तो कोष्ठक का एक नया सेट सभी तर्कों को एन्कोड करना होगा :

(() => "foo")() // -> "foo"

((bow, arrow) => bow + arrow)('I took an arrow ', 'to the knee...')
// -> "I took an arrow to the knee..."

यदि फ़ंक्शन बॉडी में एक भी एक्सप्रेशन नहीं है, तो उसे कोष्ठक से घिरा होना चाहिए और परिणाम प्रदान करने के लिए एक स्पष्ट return स्टेटमेंट का उपयोग करना चाहिए:

(bar => {
  const baz = 41;
  return bar + baz;
})(1); // -> 42

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

(bar => ({ baz: 1 }))(); // -> Object {baz: 1}

अतिरिक्त कोष्ठक इंगित करते हैं कि उद्घाटन और समापन ब्रैकेट ऑब्जेक्ट शाब्दिक का हिस्सा हैं, अर्थात वे फ़ंक्शन बॉडी के सीमांकक नहीं हैं।

लेक्सिकल स्कोपिंग एंड बाइंडिंग ("यह" का मूल्य)

एरो फ़ंक्शंस lexically scoped हैं ; इसका मतलब यह है कि उनकी this बाइंडिंग आसपास के दायरे के संदर्भ से जुड़ी है। यही कारण है कि कहने के लिए है, जो कुछ है this एक तीर फ़ंक्शन का उपयोग करके संरक्षित किया जा सकता को दर्शाता है।

निम्नलिखित उदाहरण पर एक नज़र डालें। क्लास Cow में एक विधि है जो इसे 1 सेकंड के बाद होने वाली ध्वनि को प्रिंट करने की अनुमति देती है।

class Cow {

  constructor() {
    this.sound = "moo";
  }

  makeSoundLater() {
    setTimeout(() => console.log(this.sound), 1000);
  }
}

const betsy = new Cow();

betsy.makeSoundLater();

makeSoundLater() विधि में, this संदर्भ Cow ऑब्जेक्ट के वर्तमान उदाहरण को संदर्भित करता है, इसलिए उस स्थिति में जहां मैं betsy.makeSoundLater() हूं, this संदर्भ betsy को संदर्भित करता है।

तीर फ़ंक्शन का उपयोग करके, मैं this संदर्भ को संरक्षित करता हूं ताकि मैं this संदर्भ बना this.sound जब इसे प्रिंट करने का समय आता है, जो "म्यू" को ठीक से प्रिंट करेगा।

यदि आपने तीर फ़ंक्शन के स्थान पर एक नियमित फ़ंक्शन का उपयोग किया था, तो आप कक्षा के भीतर होने का संदर्भ खो देंगे, और सीधे sound संपत्ति तक पहुंचने में सक्षम नहीं होंगे।

तर्क वस्तु

एरो फ़ंक्शंस एक तर्क वस्तु को उजागर नहीं करते हैं; इसलिए, arguments को मौजूदा दायरे में एक चर के रूप में संदर्भित किया जाएगा।

const arguments = [true];
const foo = x => console.log(arguments[0]);

foo(false); // -> true

इसके कारण, तीर के कार्यों को उनके कॉलर / कैली के बारे में भी पता नहीं है ।

हालांकि, एक तर्क वस्तु की कमी कुछ किनारे के मामलों में एक सीमा हो सकती है, बाकी पैरामीटर आमतौर पर एक उपयुक्त विकल्प होते हैं।

const arguments = [true];
const foo = (...arguments) => console.log(arguments[0]);

foo(false); // -> false

निहित प्रतिफल

एरो फ़ंक्शंस में केवल घुंघराले ब्रेसिज़ को छोड़ने से मान वापस आ सकते हैं जो परंपरागत रूप से एक फ़ंक्शन के शरीर को लपेटते हैं यदि उनके शरीर में केवल एक ही अभिव्यक्ति होती है।

const foo = x => x + 1;
foo(1); // -> 2

निहित रिटर्न का उपयोग करते समय, ऑब्जेक्ट शाब्दिक को कोष्ठक में लपेटा जाना चाहिए ताकि फ़ंक्शन के शरीर के उद्घाटन के लिए घुंघराले ब्रेसिज़ गलत न हों।

const foo = () => { bar: 1 } // foo() returns undefined
const foo = () => ({ bar: 1 }) // foo() returns {bar: 1}

स्पष्ट वापसी

एरो फ़ंक्शंस क्लासिक फ़ंक्शंस के समान व्यवहार कर सकते हैं जिसमें आप return कीवर्ड का उपयोग करके उनसे स्पष्ट रूप से मान return सकते हैं; बस अपने फ़ंक्शन के शरीर को घुंघराले ब्रेसिज़ में लपेटें, और एक मान लौटाएं:

const foo = x => {
  return x + 1;
}

foo(1); // -> 2

तीर एक निर्माता के रूप में कार्य करता है

new कीवर्ड के साथ उपयोग किए जाने पर एरो फ़ंक्शंस एक TypeError फेंक देंगे।

const foo = function () {
  return 'foo';
}

const a = new foo();

const bar = () => {
  return 'bar';
}

const b = new bar(); // -> Uncaught TypeError: bar is not a constructor...