हस्ताक्षर और पैरामीटर

गो में, फ़ंक्शन func के साथ घोषित किए जाते हैं। हस्ताक्षर सिंटैक्स भिन्न है सी/जावा से: प्रकार पैरामीटर नाम के बाद जाता है, एक द्वारा अलग किया गया अंतरिक्ष. यह एक ऐसा विकल्प है जिसका उच्चारण बेहतर ढंग से किया जाता है - इसके बजाय "n प्रकार int"। "इंट एन" का।

मूल वाक्यविन्यास

func sum(a int, b int) int {
    return a + b
}

func greet(name string) {
    fmt.Println("ciao", name)
}

बिना रिटर्न वैल्यू वाला फ़ंक्शन केवल रिटर्न प्रकार को छोड़ देता है।

एक ही प्रकार के लगातार पैरामीटर

यदि कई लगातार पैरामीटर समान प्रकार साझा करते हैं, तो आप घोषणा कर सकते हैं यह आखिरी बार सिर्फ एक बार है। यह मुहावरेदार है और आप इसे हर जगह देखेंगे:

func sum(a, b int) int { return a + b }
func max3(a, b, c float64) float64 { /* ... */ }
func parse(s, sep string, limit int) []string { /* ... */ }

निर्यातित बनाम गैर-निर्यातित फ़ंक्शन

गो में, दृश्यता नाम से निर्धारित होती है: पहचानकर्ता जो शुरू होते हैं बड़े अक्षर के साथ निर्यात होते हैं (अन्य पैकेजों से दृश्यमान), अन्य पैकेज के लिए निजी हैं।

func Sum(a, b int) int { ... }    // esportata
func helper() { ... }              // privata al package

मूल्यों के रूप में कार्य करता है

फ़ंक्शंस प्रथम श्रेणी के मान हैं: आप उन्हें असाइन कर सकते हैं, उन्हें पास कर सकते हैं, और उन्हें वापस करो. हम बंद करने के पाठ में गहराई से उतरेंगे।

op := sum            // op ha tipo func(int, int) int
fmt.Println(op(2, 3)) // 5

main और init: दो विशेष नाम

• func main() main पैकेज का प्रवेश बिंदु है। कोई तर्क नहीं, कोई वापसी मान नहीं.
• func init() को पैकेज स्टार्टअप पर स्वचालित रूप से कॉल किया जाता है (यहां तक कि एकाधिक भी)। कई बार यदि कई फ़ाइलें एक को परिभाषित करती हैं)। सेटअप के लिए उपयोगी; इसे संयम से प्रयोग करें.

इसे अजमाएं

func f(? ?) {}

संक्षिप्त

• func name(param type, ...) returnType { ... }.
• नाम के बाद टाइप करें; एक ही प्रकार के लगातार पैरामीटर → इसे केवल एक बार घोषित करें।
• अपरकेस प्रारंभिक = निर्यातित; लोअरकेस = पैकेज के लिए निजी।
• कार्य प्रथम श्रेणी (असाइन करने योग्य, पारित करने योग्य) हैं।
• main और init विशेष शब्दार्थ वाले आरक्षित नाम हैं।