लज़ान्या मास्टर

फंक्शन की मदद से आप कोड को एक ऐसी इकाई में बाँध सकते हैं जिसे दोबारा इस्तेमाल किया जा सकता है। इसमें func कीवर्ड, फंक्शन का नाम, और गोल ब्रैकेट में शून्य या उससे अधिक पैरामीटरों और टाइपों की अल्पविराम से अलग की गई सूची होती है।

फंक्शन के पैरामीटर

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

import "fmt"

// No parameters
func PrintHello() {
    fmt.Println("Hello")
}

// Two parameters
func PrintGreetingName(greeting string, name string) {
  fmt.Println(greeting + " " + name)
}

एक ही टाइप के पैरामीटरों को साथ-साथ घोषित किया जा सकता है, और उनके बाद एक ही बार टाइप लिखना होता है।

import "fmt"

func PrintGreetingName(greeting, name string) {
  fmt.Println(greeting + " " + name)
}

पैरामीटर और आर्गुमेंट

चलिए जल्दी से दो शब्दों को समझ लेते हैं जिन्हें अक्सर आपस में मिला दिया जाता है: parameters और arguments। फंक्शन के पैरामीटर वे नाम होते हैं जो फंक्शन के सिग्नेचर में परिभाषित होते हैं, जैसे ऊपर दिए गए PrintGreetingName फंक्शन में greeting और name। फंक्शन के आर्गुमेंट वे वास्तविक वैल्यू होती हैं जो फंक्शन को कॉल करते समय उसके पैरामीटरों को दी जाती हैं। जैसे नीचे के उदाहरण में "Hello" और "Katrina" वे आर्गुमेंट हैं जो greeting और name पैरामीटरों को दिए गए हैं:

PrintGreetingName("Hello", "Katrina")

रिटर्न वैल्यू

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

func Hello(name string) string {
  return "Hello " + name
}

func HelloAndGoodbye(name string) (string, string) {
  return "Hello " + name, "Goodbye " + name
}

फंक्शन को कॉल करना

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

import "fmt"

// No parameters, no return value
func PrintHello() {
    fmt.Println("Hello")
}
// Called like this:
PrintHello()

// One parameter, one return value
func Hello(name string) string {
  return "Hello " + name
}
// Called like this:
greeting := Hello("Dave")

// Multiple parameters, multiple return values
func SumAndMultiply(a, b int) (int, int) {
    return a+b, a*b
}
// Called like this:
aplusb, atimesb := SumAndMultiply(a, b)

नामित रिटर्न वैल्यू और नेक्ड रिटर्न

पैरामीटरों की तरह रिटर्न वैल्यू को नाम भी दिया जा सकता है, हालाँकि यह ज़रूरी नहीं है। अगर रिटर्न वैल्यू को नाम दिए गए हों, तो बिना आर्गुमेंट वाला return स्टेटमेंट उन्हीं वैल्यू को लौटा देता है। इसे 'नेक्ड' रिटर्न कहते हैं।

func SumAndMultiplyThenMinus(a, b, c int) (sum, mult int) {
    sum, mult = a+b, a*b
    sum -= c
    mult -= c
    return
}

वैल्यू से पास करना और रेफरेंस से पास करना

वैल्यू से पास करने और रेफरेंस से पास करने की धारणा को साफ करना भी ज़रूरी है।

पहले वैल्यू से पास करना समझ लेते हैं। नीचे के उदाहरण में जब हम वेरिएबल val को MultiplyByTwo फंक्शन को पास करते हैं, तो वास्तव में val की एक कॉपी पास होती है। इस वजह से newVal में नई वैल्यू 4 आ जाती है, लेकिन मूल वेरिएबल val अब भी 2 ही रहता है। भीतर ही भीतर Go मूल वैल्यू की एक कॉपी बना देता है, ताकि फंक्शन सिर्फ इसी कॉपी को, यानी v को, बदले।

val := 2
func MultiplyByTwo(v int) int {
    v = v * 2
    return v
}
newVal := MultiplyByTwo(val)
// newval is 4, val is still 2 because only a copy of its value was passed into the function

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

पॉइंटर

रेफरेंस से पास करने के लिए हम pointer का इस्तेमाल करते हैं। फंक्शन को pointer आर्गुमेंट के तौर पर पास करके हम सिर्फ डेटा की कॉपी पर काम करने के बजाय फंक्शन को पास किए गए मूल डेटा को बदल सकते हैं।

फिलहाल इतना जान लेना काफी है कि पॉइंटर टाइप को फंक्शन के सिग्नेचर में टाइप के आगे लगे * से पहचाना जा सकता है।

func HandlePointers(x, y *int) {
    // Some logic to handle integer values referenced by pointers x and y
}

अगर pointer की धारणा उलझी हुई लगे तो कोई बात नहीं। सिलेबस में आगे एक अलग सेक्शन है जो पॉइंटर पर आपकी पकड़ मज़बूत करने में मदद करेगा।

अपवाद

ध्यान दीजिए कि slices और maps ऊपर बताए गए नियम के अपवाद हैं। जब हम किसी फंक्शन को आर्गुमेंट के तौर पर slice या map पास करते हैं, तो उन्हें पॉइंटर टाइप की तरह माना जाता है, भले ही उनके टाइप में कोई साफ * न हो। इसका मतलब है कि अगर हम किसी फंक्शन को स्लाइस या मैप पास करें और उसका मूल डेटा बदलें, तो ये बदलाव मूल स्लाइस या मैप पर भी दिखाई देंगे।