फंक्शन में

फंक्शन के बारे में

फंक्शन कोड का एक व्यवस्थित ब्लॉक होता है, जिसे दोबारा इस्तेमाल किया जा सकता है और जिसका इस्तेमाल कोई काम करने के लिए किया जाता है। JavaScript में फंक्शन बनाने के कई तरीके हैं। यहाँ हम फंक्शन डिक्लेरेशन और फंक्शन एक्सप्रेशन देखेंगे। एरो फंक्शन जैसी दूसरी संभावनाओं पर दूसरे कॉन्सेप्ट में बात की जाएगी।

फंक्शन डिक्लेरेशन

JavaScript में फंक्शन बनाने का मानक तरीका फंक्शन डिक्लेरेशन है, जिसे फंक्शन डेफिनिशन या फंक्शन स्टेटमेंट भी कहा जाता है।

इसमें function कीवर्ड, फंक्शन का नाम, और गोल ब्रैकेट के अंदर कॉमा से अलग किए गए पैरामीटर की सूची होती है। इसके बाद फंक्शन के अंदर का कोड आता है (यानी उन स्टेटमेंट का समूह जो बताते हैं कि फंक्शन क्या करता है), जिसे घुंघराले ब्रैकेट में लिखा जाता है।

function someName(param1, param2, param3) {
  // ...
}

फंक्शन का इस्तेमाल करना

JavaScript में फंक्शन को कॉल करने के लिए उसका नाम लिखा जाता है, और उसके बाद गोल ब्रैकेट में आर्गुमेंट लिखे जाते हैं।

someName(arg1, arg2, arg3);

JavaScript में सिर्फ फंक्शन का नाम लिखने से फंक्शन कॉल नहीं होता।

function sayHello() {
  console.log('Hello, World!');
}

sayHello;
// => [Function: sayHello]
// The text representations varies between environments.

sayHello();
// => 'Hello, World!'

पैरामीटर

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

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

  const num = 0;
  
  function increase(number) {
    number = number + 1;
  }
  
  increase(num);
  num;
  // => 0
  

• ऑब्जेक्ट, ऐरे और फंक्शन जैसी वैल्यू के साथ यह अलग होता है। चूँकि रेफरेंस की कॉपी बनती है, इसलिए दोबारा असाइन करने से मूल वैल्यू पर असर नहीं पड़ता। लेकिन चूँकि यहाँ शैलो कॉपी की बात है, फंक्शन के अंदर आर्गुमेंट में बदलाव करने से वह मूल वैल्यू भी बदल जाती है जो अंदर भेजी गई थी।

  const nums = [0, 1, 2, 3, 4];
  
  function pushFive(arr) {
    arr.push(5);
  }
  
  pushFive(nums);
  nums;
  // => [0, 1, 2, 3, 4, 5]
  

JavaScript में फंक्शन डिक्लेरेशन में बनाए गए सभी पैरामीटर डिफ़ॉल्ट रूप से वैकल्पिक होते हैं। अगर किसी फंक्शन को पैरामीटर की संख्या से कम आर्गुमेंट दिए जाएँ, तो फंक्शन के अंदर जो आर्गुमेंट नहीं मिले वे undefined होते हैं। ज़्यादा जानकारी के लिए Null और Undefined देखिए। कई मामलों में यह बेहतर होता है कि अगर कोई वैल्यू या undefined प्रॉपर्टी न दी गई हो, तो पैरामीटर को शुरू में ही डिफ़ॉल्ट वैल्यू दे दी जाए। ऐसा फंक्शन डेफिनिशन में सीधे डिफ़ॉल्ट पैरामीटर लिखकर किया जा सकता है।

function someName(param1 = defaultValue1, param2 = defaultValue2) {
  // ...
}

किसी फंक्शन को फंक्शन डेफिनिशन में लिखे पैरामीटर से ज़्यादा आर्गुमेंट के साथ भी कॉल किया जा सकता है। सभी आर्गुमेंट, वे अतिरिक्त आर्गुमेंट भी, arguments "ऐरे" में मिलते हैं।

ऐसे फंक्शन भी बनाए जा सकते हैं जो कितने भी आर्गुमेंट ले सकें (वेरिएडिक फंक्शन)। ज़्यादा जानकारी के लिए रेस्ट और स्प्रेड ऑपरेटर में रेस्ट पैरामीटर देखिए।

return स्टेटमेंट

एक return स्टेटमेंट फंक्शन को रोक देता है और बताता है कि फंक्शन को कॉल करने वाले को कौन-सी वैल्यू लौटाई जानी है। एक फंक्शन में कई return स्टेटमेंट हो सकते हैं।

function checkNumber(num) {
  if (num === 0) {
    return 'You passed 0, please provide another number.';
  }

  return 'Thanks for passing such a nice number.';
}

जिस फंक्शन से कोई वैल्यू return नहीं होती या जिसमें कोई return स्टेटमेंट नहीं होता, उसका परिणाम undefined होता है। JavaScript में कोई अंतर्निहित return नहीं होता।

function nakedReturn(a) {
  a * 2;
  return;
}

nakedReturn(1);
// => undefined

function noReturn(a) {
  a * 2;
}

noReturn(1);
// => undefined

JavaScript में आप सिर्फ एक ही वैल्यू लौटा सकते हैं। अगर आपको ज़्यादा जानकारी देनी है, तो पहले उसे एक ही चीज़ में मिलाना होगा, आम तौर पर ऑब्जेक्ट या ऐरे में।

function divide(a, b) {
  return {
    quotient: Math.floor(a / b),
    remainder: a % b,
  };
}

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

फंक्शन डिक्लेरेशन अपने आप में पूरा स्टेटमेंट होता है। लेकिन कभी-कभी फंक्शन को किसी दूसरे एक्सप्रेशन के हिस्से के रूप में बनाना काम आता है, जैसे किसी असाइनमेंट में, फंक्शन के पैरामीटर के रूप में (कॉलबैक), या किसी ऑब्जेक्ट में वैल्यू के रूप में। यह फंक्शन एक्सप्रेशन से किया जा सकता है। इसका सिंटैक्स फंक्शन डिक्लेरेशन जैसा ही होता है, बस फंक्शन का नाम हटाकर अनाम फंक्शन बनाया जा सकता है।

const someFunction = function (param) {
  // ...
};

someOtherFunction(function (param) {
  // ...
});

const obj = {
  someFunction: function (param) {
    // ...
  },
};

स्कोप

JavaScript में फंक्शन एक नया एक्ज़ीक्यूशन कॉन्टेक्स्ट लेकर आता है। फंक्शन के अंदर बनाए गए वेरिएबल उस फंक्शन के बाहर इस्तेमाल नहीं किए जा सकते। लेकिन पैरेंट स्कोप में बनाए गए वेरिएबल (यानी वह स्कोप जहाँ यह फंक्शन खुद बनाया गया था) फंक्शन के अंदर इस्तेमाल किए जा सकते हैं। स्कोप पर MDN के डॉक्युमेंटेशन में इस व्यवहार के उदाहरण दिखाए गए हैं।

JavaScript में वेरिएबल के स्कोप के बारे में और जानने के लिए क्लोज़र पर एक नज़र डालिए।