नए es6 एरो फ़ंक्शंस कहते हैं कि returnकुछ परिस्थितियों में निहित है:
अभिव्यक्ति भी उस फ़ंक्शन का निहित रिटर्न मान है।
क्या मामलों में मुझे returnes6 तीर फ़ंक्शन के साथ उपयोग करने की आवश्यकता है ?
नए es6 एरो फ़ंक्शंस कहते हैं कि returnकुछ परिस्थितियों में निहित है:
अभिव्यक्ति भी उस फ़ंक्शन का निहित रिटर्न मान है।
क्या मामलों में मुझे returnes6 तीर फ़ंक्शन के साथ उपयोग करने की आवश्यकता है ?
जवाबों:
जैक्सन आंशिक रूप से किया गया है इस जवाब एक समान प्रश्न में:
अस्पष्ट वापसी, लेकिन केवल अगर कोई ब्लॉक नहीं है।
- जब एक-लाइनर कई लाइनों तक फैल जाता है और प्रोग्रामर एक जोड़ना भूल जाता है तो यह परिणाम होगा
return।- इंप्लिमेंट रिटर्न सिंटैक्टिकली एंबुलेस है।
(name) => {id: name}वस्तु लौटाता है{id: name}... सही? गलत। यह लौट आता हैundefined। वे ब्रेसिज़ एक स्पष्ट ब्लॉक हैं।id:एक लेबल है।
मैं इसे एक खंड की परिभाषा में जोड़ूंगा :
एक ब्लॉक स्टेटमेंट (या अन्य भाषाओं में कंपाउंड स्टेटमेंट) का उपयोग शून्य या अधिक स्टेटमेंट को ग्रुप करने के लिए किया जाता है। ब्लॉक को कर्ली ब्रैकेट की एक जोड़ी द्वारा सीमांकित किया गया है।
उदाहरण :
// returns: undefined
// explanation: an empty block with an implicit return
((name) => {})()
// returns: 'Hi Jess'
// explanation: no block means implicit return
((name) => 'Hi ' + name)('Jess')
// returns: undefined
// explanation: explicit return required inside block, but is missing.
((name) => {'Hi ' + name})('Jess')
// returns: 'Hi Jess'
// explanation: explicit return in block exists
((name) => {return 'Hi ' + name})('Jess')
// returns: undefined
// explanation: a block containing a single label. No explicit return.
// more: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label
((name) => {id: name})('Jess')
// returns: {id: 'Jess'}
// explanation: implicit return of expression ( ) which evaluates to an object
((name) => ({id: name}))('Jess')
// returns: {id: 'Jess'}
// explanation: explicit return inside block returns object
((name) => {return {id: name}})('Jess') nameजिसमें फ़ंक्शन को कोष्ठक में संलग्न किया गया है और एक तर्क के साथ "जेस" लिखा है। के बीच कोड =>और )('Jess')प्रत्येक मामले में तीर समारोह का मुख्य भाग है। इसे तत्काल रूप से लागू किए गए फ़ंक्शन के संक्षिप्त रूप की तरह पर विचार करें(function (name) { return { id: name } })('Jess')
{}) या ब्लॉक , यह मानता है कि { }एक ब्लॉक को दर्शाता है। इसका मतलब है कि जब यह देखता है id: name, तो यह सोचता id:है कि यह एक लेबल बनाने वाला एक अभिव्यक्ति है (जेएस की एक बहुत ही असामान्य रूप से उपयोग की जाने वाली विशेषता जो प्रवाह नियंत्रण और सौदों का उपयोग करती है :), और फिर nameनिम्नलिखित id:केवल एक अलग बयान है जिसमें केवल चर शामिल है name(और कुछ नहीं करता)।
मैं इस नियम को समझता हूं ...
ऐसे कार्यों के लिए जो प्रभावी रूप से रूपांतरित होते हैं (तर्कों की एक-पंक्ति-जोड़तोड़), वापसी निहित है।
उम्मीदवार हैं:
// square-root
value => Math.sqrt(value)
// sum
(a,b) => a+bअन्य परिचालनों के लिए (एक-लाइनर्स से अधिक जिसे ब्लॉक की आवश्यकता होती है, वापसी स्पष्ट होनी चाहिए
यहाँ एक और मामला है।
जब रिएक्ट में एक कार्यात्मक घटक लिखते हैं, तो आप कोष्ठक का उपयोग कर सकते हैं, जो कि स्पष्ट रूप से लौटे JSX को लपेट सकते हैं।
const FunctionalComponent = () => (
<div>
<OtherComponent />
</div>
);यहाँ एक और मामला है जिसने मुझे कुछ परेशानी दी है।
// the "tricky" way
const wrap = (foo) => (bar) => {
if (foo === 'foo') return foo + ' ' + bar;
return 'nofoo ' + bar;
}यहां हम एक फ़ंक्शन को एक अनाम फ़ंक्शन लौटाते हुए परिभाषित करते हैं। "मुश्किल" बिट यह है कि बाहरी फ़ंक्शन (बार के साथ भाग लेने वाला = = ...) के लिए फ़ंक्शन बॉडी नेत्रहीन "ब्लॉक" की तरह दिखता है, लेकिन यह नहीं है। चूंकि यह नहीं है, निहित रिटर्न किक में।
यहां बताया गया है कि रैप कैसे निष्पादित होगा:
// use wrap() to create a function withfoo()
const withfoo = wrap('foo');
// returns: foo bar
console.log(withfoo('bar'));
// use wrap() to create a function withoutfoo()
const withoutfoo = wrap('bar');
// returns: nofoo bar
console.log(withoutfoo('bar'));जिस तरह से मैंने यह सुनिश्चित करने के लिए इसे अनपैक किया, मुझे यह समझ में आ गया कि यह फंक्शंस को "अनरोज करने" के लिए था।
यहाँ पहले कोड ब्लॉक के शब्दार्थ समतुल्य है, बस लिपटे हुए शरीर को बनाते हुए () स्पष्ट वापसी करते हैं। यह परिभाषा ऊपर के समान परिणाम उत्पन्न करती है। यह वह जगह है जहाँ डॉट्स कनेक्ट होते हैं। नीचे दिए गए एक के साथ पहले कोड ब्लॉक की तुलना करें, और यह स्पष्ट है कि एक तीर फ़ंक्शन खुद को एक अभिव्यक्ति के रूप में माना जाता है , ब्लॉक नहीं है और निहित रिटर्न है ।
// the explicit return way
const wrap = (foo) => {
return (bar) => {
if (foo === 'foo') return foo + ' ' + bar;
return 'nofoo ' + bar;
}
}रैप का पूरी तरह से अनारक्षित संस्करण इस तरह होगा, जो वसा के संस्करण के रूप में कॉम्पैक्ट नहीं है, लेकिन यह समझने में बहुत आसान लगता है।
// the "no arrow functions" way
const wrap = function(foo) {
return function(bar) {
if (foo === 'foo') return foo + ' ' + bar;
return 'nofoo ' + bar;
};
};अंत में, दूसरों के लिए जिन्हें मेरा कोड पढ़ना हो सकता है, और मुझे भविष्य में, मुझे लगता है कि मैं गैर-तीर संस्करण पर जाना पसंद करूंगा, जिसे पहली नज़र में नेत्रहीन रूप से समझ लिया जा सकता है, न कि उस तीर के बजाय जो थोड़ा सा लेता है विचार (और मेरे मामले में प्रयोग) को टटोलना है।
एरो फ़ंक्शंस आपको एक अंतर्निहित वापसी की अनुमति देते हैं: returnकीवर्ड का उपयोग किए बिना मान लौटाए जाते हैं ।
यह तब काम करता है जब फ़ंक्शन बॉडी में एक ऑन-लाइन स्टेटमेंट होता है:
const myFunction = () => 'test'
console.log(myFunction()) //'test'एक अन्य उदाहरण, एक वस्तु लौटना (कोष्ठक में घुंघराले कोष्ठक को लपेटना याद रखें इससे बचने के लिए इसे रैपिंग फंक्शन बॉडी कार्डबोर्ड माना जाता है:)
const myFunction = () => ({value: 'test'})
console.log(myFunction()) //{value: 'test'}