रिटर्न कीवर्ड

return का इस्तेमाल करके वह वैल्यू बताएं जो फ़ंक्शन को आखिरी नतीजे के तौर पर बनाना चाहिए. जब इंटरप्रेटर किसी return स्टेटमेंट पर पहुंचता है, तो उस स्टेटमेंट वाला फ़ंक्शन तुरंत खत्म हो जाता है. साथ ही, तय की गई वैल्यू उस कॉन्टेक्स्ट पर वापस आ जाती है जहां फ़ंक्शन को कॉल किया गया था:

const myFunction = function() {
   return 2 + 2;
}

myFunction();
> 4

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

const myFunction = function() {
   return 2 + 2;
}

myFunction() + myFunction();
> 8

बिना एक्सप्रेशन के return स्टेटमेंट, फ़ंक्शन को खत्म करता है और नतीजे के तौर पर undefined दिखाता है:

const myFunction = function() {
   return;
}

myFunction();
> undefined

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

const myFunction = function() {
   return true;
   console.log( "This is a string." );
}

myFunction();
> true

इसके अलावा, मिलने वाले return स्टेटमेंट के बाद कोड मिलने पर, कुछ ब्राउज़र के डेवलपमेंट कंसोल में चेतावनी (लेकिन कोई गड़बड़ी नहीं) मिल सकती है:

const myFunction = function() {
   return true;
   console.log( "This is a string." );
}
> unreachable code after return statement

myFunction();
> true

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

const myFunction = function( myParameter ) {
   if( myParameter === undefined ) {
    return "This is the result.";
   }
   return "This is the alternate result.";
}

myFunction();
> "This is the result."

myFunction( true );
> "This is the alternate result."

"शॉर्ट सर्किट" सुविधा का इस्तेमाल करने पर, शुरुआती return का इस्तेमाल करने पर, फ़ंक्शन के आखिर में मौजूद return स्टेटमेंट की तुलना में, ज़्यादा छोटा कोड दिया जा सकता है. उदाहरण के लिए, नीचे दिया गया फ़ंक्शन यह तय करता है कि पास की गई वैल्यू, पांच या उससे ज़्यादा वर्णों वाली स्ट्रिंग है या नहीं. अगर पास की गई वैल्यू कोई लिटरल वैल्यू नहीं है, तो वर्णों की गिनती करने वाला कोड ज़रूरी नहीं है. साथ ही, फ़ंक्शन तुरंत false नतीजा दिखा सकता है:

function myFunction( myString ) {
   if( typeof myString !== "string" ) {
    return false;
   }
   if( myString.length >= 5 ) {
    return true;
   } else {
    return false;
   }
}

myFunction( 100 );
> false

myFunction( "St" );
> false

myFunction( "String." );
> true

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

const myFunction = () => 2 + 2;

myFunction();
> 4

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

const myFunction = () => { 2 + 2 };

myFunction();
> undefined

const myFunction = () => { return 2 + 2 };

myFunction();
> 4

जांचें कि आपको कितना समझ आया