Scala में फ़ंक्शंस और मेथड्स की बुनियादी बातें

Scala के बारे में और सीखने में रुचि है? DataCamp का Introduction to Scala कोर्स करें।

Scala एक फंक्शनल प्रोग्रामिंग भाषा है जिसमें फ़ंक्शंस फर्स्ट-क्लास वैल्यूज़ के रूप में भी हैं और मेथड्स भी, तथा इन दोनों में समानताएँ और विभिन्नताएँ मौजूद हैं। फ़ंक्शंस और मेथड्स दोनों ही रीउस करने योग्य कोड के ब्लॉक होते हैं, जो दोहराए जाने वाले कोड को एक जगह संग्रहीत करते हैं, जिससे किसी विशेष कार्य के लिए फ़ंक्शन कॉल किया जा सके। ये कोड को डिबग और संशोधित करना भी आसान बनाते हैं।

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

मेथड डिक्लेरेशन और डेफिनिशन

Scala में मेथड डिक्लेरेशन और डेफिनिशन का सिंटैक्स नीचे दिया है:

def 'method_name' ('parameters':'return_type_parameters') : ('return_type_of_method') = {
    'method_body'
     return 'value'
}

Scala में मेथड निम्न भागों से शुरू होता है:

1. 'def': वह कीवर्ड जिससे मेथड्स डिक्लेयर किए जाते हैं।
2. 'method_name': आपके मेथड का नाम, जो लोअर कैमल केस में होता है।
3. 'parameters': मेथड पैरामीटर; यह शून्य या एक पैरामीटर हो सकते हैं, और यदि एक से अधिक हों तो उन्हें कॉमा से अलग किया जाता है।
4. 'return_type_of_parameters': यह 'parameters_list' के डेटा टाइप के अनुसार मेल खाना चाहिए और अनिवार्य है।
5. 'return_type_of_method': वैकल्पिक है; डिफ़ॉल्ट रूप से 'Unit' रिटर्न होता है, लेकिन 'return' कीवर्ड से वैल्यू रिटर्न की जा सकती है।
6. असाइनमेंट सिंबल ('='): वैकल्पिक है; इसका उपयोग करने पर रिटर्न वैल्यू असाइन होगी, और न उपयोग करने पर मेथड कुछ रिटर्न नहीं करेगा।
7. 'method_body': घुंघराली ब्रेसेज़ '{}' में समाहित कोड ब्लॉक, जिसमें आवश्यक लॉजिक, कार्य, या ऑपरेशंस होते हैं।
8. return: आवश्यक वैल्यू रिटर्न करने और प्रोग्राम समाप्त करने के लिए प्रयुक्त कीवर्ड, लेकिन Scala में क्वचित ही उपयोग होता है।

मेथड कॉल

Scala में मेथड कॉल का सिंटैक्स नीचे है:

    method_name(arguments)

मेथड कॉल को 'method_name' के माध्यम से, जो संबंधित मेथड का नाम है, आर्ग्युमेंट्स पास करके आसानी से किया जा सकता है।

नेम्ड आर्ग्युमेंट्स वाला मेथड

नेम्ड आर्ग्युमेंट्स वाले मेथड में, मेथड कॉल के दौरान आर्ग्युमेंट्स को मेथड के पैरामीटर्स में नाम देकर पास किया जा सकता है, जहाँ प्रत्येक आर्ग्युमेंट को एक-एक करके पैरामीटर्स से मिलाया जाता है। नीचे आप फ़ंक्शन डिक्लेरेशन व डेफिनिशन के साथ, मेथड कॉल के दौरान आर्ग्युमेंट्स पास करने का उदाहरण देखेंगे:

object calculateResult {
      def funSub(x:Int, y:Int) : Int =
   {

       var diff:Int = 0
       diff = x - y

       // return value
       return diff
   }
   def main(args: Array[String]) {

      // Function call
      println("Difference of the value is: " + funSub(8,6));
      println("Difference of the value is " + funSub(y=6,x=8));
   }
}

ऊपर के प्रोग्राम का आउटपुट है:
Difference of the value is: 2
Difference of the value is: 2

ऊपर के प्रोग्राम में 'calculateResult' नाम का ऑब्जेक्ट है, और उसके भीतर 'funSub' नाम का एक मेथड है जिसके पैरामीटर x और y का रिटर्न टाइप 'Int' है, तथा मेथड का समग्र रिटर्न टाइप भी 'Int' है। इसके बाद असाइनमेंट स्टेटमेंट आता है जो रिटर्न वैल्यू असाइन करता है। घुंघराली ब्रेसेज़ मेथड बॉडी की शुरुआत दर्शाती हैं, जहाँ 'diff' वैरिएबल को 0 की प्रारंभिक वैल्यू के साथ इनिशियलाइज़ किया गया है। मुख्य मेथड में किया गया मेथड कॉल 'funSub(8,6)' में 8 'x' से और 6 'y' से मेल खाता है; घटाव ऑपरेशन किया जाता है, 'diff' की वैल्यू रिटर्न होकर प्रिंट होती है। इसी तरह, 'funSub(x=8,y=6)' में मेथड कॉल के समय पैरामीटर्स को नाम दिए जाने से क्रम मायने नहीं रखता; वही ऑपरेशन होता है, वैल्यू रिटर्न होकर परिणाम प्रिंट होता है।

डिफ़ॉल्ट पैरामीटर वैल्यूज़

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

object calculateResult {
      def funSub(x:Int=9, y:Int=6) : Int =
   {

       var diff:Int = 0
       diff = x - y

       // return value
       return diff
   }
   def main(args: Array[String]) {

      // Function call
    print( "The final value is: " + funSub() );

   }
}

ऊपर के प्रोग्राम का आउटपुट है:
The final value is: 3

आप देख सकते हैं कि ऊपर के प्रोग्राम में 'calculateResult' नाम का ऑब्जेक्ट है और उसके भीतर 'funSub' नाम का मेथड है, जिसके पैरामीटर्स x और y दोनों का रिटर्न टाइप 'Int' है, तथा मेथड का समग्र रिटर्न टाइप भी 'Int' है; इसके बाद असाइनमेंट स्टेटमेंट आता है जो रिटर्न वैल्यू असाइन करेगा। घुंघराली ब्रेसेज़ मेथड बॉडी की शुरुआत दर्शाती हैं, जहाँ 'diff' वैरिएबल को 0 से इनिशियलाइज़ किया गया है। मेथड कॉल मुख्य मेथड के भीतर होता है, जहाँ 'funSub()' कॉल होने पर x को 9 और y को 6 से इनिशियलाइज़ किया जाता है, ऑपरेशन किया जाता है, और 'diff' की वैल्यू रिटर्न होकर प्रिंट होती है।

वेरिएबल-लेंथ आर्ग्युमेंट्स

वेरिएबल-लेंथ आर्ग्युमेंट्स वे आर्ग्युमेंट्स होते हैं जो आर्ग्युमेंट्स की किसी भी संख्या को स्वीकार कर सकते हैं और जिन्हें उपयोगकर्ता या क्लाइंट द्वारा पास किया जा सकता है। मेथड में अंतिम पैरामीटर को '*' का उपयोग करके डिक्लेयर किया जाता है, जो दोहराया जा सकता है।

object variableArgument {
    def main(args: Array[String]) {
       printAll("Scala", "is", "great")
    }

    def printAll(strings: String*) {
        var i : Int = 0;

      for( value <- strings ){
         println(value);
         i = i + 1;
      }
    }
}

ऊपर के प्रोग्राम का आउटपुट है:
Scala
is
great

आप देख सकते हैं कि ऊपर के प्रोग्राम में 'variableArgument' नाम का ऑब्जेक्ट है, जिसमें 'printAll' मेथड है जहाँ वेरिएबल-लेंथ आर्ग्युमेंट 'String*' अंत में परिभाषित है, और मेथड कॉल के दौरान स्ट्रिंग्स की एक सूची पास की जा सकती है। पास की गई स्ट्रिंग्स की सूची पर लूप चलाकर उन्हें मुख्य फ़ंक्शन के भीतर आउटपुट में दिखाया जाता है।

रिकर्शन फ़ंक्शन

रिकर्शन एक तकनीक है जो फंक्शनल प्रोग्रामिंग में उपयोग होती है, जहाँ समस्या को बार-बार छोटे-छोटे उपसमस्याओं में तोड़कर हल किया जाता है, जो मूल समस्या के समान होती हैं। छोटी समस्याएँ हल कर ली जाती हैं और उनके हल को मिलाकर मूल समस्या का समाधान प्राप्त किया जाता है। इसलिए इसे डिवाइड-एंड-कन्कर या डिक्रीज़-एंड-कन्कर समस्या कहा जाता है, जो कोड को साफ़ और सुरुचिपूर्ण बनाता है। रिकर्सिव फ़ंक्शन लिखते समय दो बातों पर सख्ती से ध्यान देना होता है:

• बेस केस: किसी फ़ंक्शन में एक से अधिक बेस केस हो सकते हैं; इन्हें पहचानना ज़रूरी है, अन्यथा अनंत रिकर्शन हो सकता है। इसका एक समाधान होना चाहिए, यानी बिना रिकर्शन के प्राप्त किया जा सकने वाला सरल आउटपुट या समाधान।
• रिकर्सिव केस: वह स्थिति जहाँ रिकर्सिव फ़ंक्शन लागू होता है, यानी रिकर्सिव कॉल्स की जाती हैं। समस्या का सार यह है कि हर रिकर्सिव कॉल में साइज़ घटना चाहिए, यानी समस्या को छोटे उपसमस्याओं में बाँटना चाहिए, जब तक कि बेस केस तक न पहुँचे। अंत में, समाधानों को मिलाकर मुख्य समस्या का समाधान प्राप्त किया जाता है—इसे डिवाइड-कन्कर अप्रोच कहते हैं।

किसी भी दिए गए संख्या का फैक्टोरियल n! होता है। इसे गणितीय रूप से इस प्रकार व्यक्त किया जा सकता है:

साथ ही, आप (n-1).(n-2)...3.2.1 को (n-1)! लिख सकते हैं। अतः किसी भी संख्या का फैक्टोरियल सदैव n.(n-1)! होता है।

अब आप नीचे समस्या को रिकर्सिव तरीके से हल करते देख सकते हैं।

object factorialDemo {
   def main(args: Array[String]) {
      for (i <- 1 to 5)
         println( "Factorial of " + i + ": = " + factorial(i) )
   }

   def factorial(n: Int): Int = {  
      if (n <= 1)
         return 1  
      else    
      return n * factorial(n - 1)
   }
}

ऊपर के प्रोग्राम का आउटपुट है:
Factorial of 1: = 1
Factorial of 2: = 2
Factorial of 3: = 6
Factorial of 4: = 24
Factorial of 5: = 120

ऊपर आप देख सकते हैं कि 'factorialDemo' नाम का ऑब्जेक्ट है और उसके भीतर 'main' फ़ंक्शन है, जिसमें पाँच बार दोहरने वाला एक लूप है और 'factorial' फ़ंक्शन का कॉल शामिल है, जहाँ रिकर्सिव फ़ंक्शन n के मान पर रिकर्सिव कॉल करता है। जब n 1 से कम या बराबर हो जाता है, तब बेस केस पर रुकता है, परिणाम रिटर्न होकर प्रिंट होता है।

अनॉनिमस फ़ंक्शन

अनॉनिमस फ़ंक्शन वे हल्के-फुल्के फ़ंक्शन डेफिनिशन होते हैं जिनका कोई नाम नहीं होता और Scala में इन्हें फंक्शन लिटरल कहा जाता है।

अनॉनिमस फ़ंक्शन के लिए सिंटैक्स व उदाहरण नीचे दिए हैं:

• अनॉनिमस फ़ंक्शन के लिए पहला सिंटैक्स और उसका उदाहरण:

सिंटैक्स:

('first_variable':'data_type', 'second_variable':'data_type') => "certain_expression"

उदाहरण:

(var1:String:var2:String) => var1 + var2

या

• अनॉनिमस फ़ंक्शन के लिए दूसरा सिंटैक्स और उसका उदाहरण:

सिंटैक्स:

 (_:'data_type')operator(_'data_type')

उदाहरण:

 (_:String)+(_:String)

पहला सिंटैक्स दर्शाता है कि "=>" के बाद का एक्सप्रेशन किसी विशेष वैल्यू का मूल्यांकन करता है, जबकि "=>" से पहले वैरिएबल्स की सूची उस एक्सप्रेशन का मूल्यांकन करने के लिए प्रयुक्त होती है।

ऊपर दिया दूसरा सिंटैक्स प्लेसहोल्डर जैसा काम करता है, जहाँ यह 'वाइल्ड कार्ड' कैरेक्टर के रूप में वैल्यू केवल एक बार स्वीकार करता है, और फिर ऑपरेटर उनके बीच संचालित होता है।

नीचे आप अनॉनिमस फ़ंक्शन का एक उदाहरण देखेंगे:

 object anonymousDemo  
{
    def main(args: Array[String])  
    {


        var function1 = (var1:Int, var2:Int) => var1 + var2
        var function2 = (_:Int) + (_:Int)

        // function call
        println(function1(5, 5))
        println(function2(7, 3))
    }
}

Initializing Scala interpreter ...



Spark Web UI available at http://DESKTOP-03TH7J0:4040
SparkContext available as 'sc' (version = 2.4.3, master = local[*], app id = local-1566986265958)
SparkSession available as 'spark'




<console>:10: error: unbound placeholder parameter

        var function2 = {_:Int} + {_:Int}

                         ^

<console>:10: error: unbound placeholder parameter

        var function2 = {_:Int} + {_:Int}

                                   ^

ऊपर के प्रोग्राम का आउटपुट है:
10
10

आप ऊपर देख सकते हैं कि 'anonymousDemo' नाम का ऑब्जेक्ट है, जिसमें 'main' फ़ंक्शन के भीतर दो अनॉनिमस फ़ंक्शंस हैं। ये सिन्टैक्टिकली अलग हैं, लेकिन वही परिणाम दे सकते हैं। 'function1' को कॉल करते समय पैरामीटर्स सीधे फ़ंक्शन कॉल से लिए जाते हैं—5 और 5 पास करने पर आउटपुट 10 प्रिंट होता है—जबकि 'function2' को 7 और 3 पास करने पर यह किसी भी वैध 'Integer' को एक-एक बार स्वीकार करता है, जोड़ का ऑपरेशन करता है और परिणाम आउटपुट करता है।

निष्कर्ष

बधाई हो, आपने यह ट्यूटोरियल पूरा पढ़ लिया है।

Scala में कई उन्नत विषय हैं, जैसे हायर-ऑर्डर फ़ंक्शंस, नेस्टेड फ़ंक्शन, करीइंग फ़ंक्शन, आदि।

संदर्भ:
TOUR OF SCALA BASICS
Scala | Functions – Basics
Scala - Functions
Anonymous Functions in Scala

DataCamp का Introduction to Scala कोर्स देखें।