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

गो में, फ़ंक्शन प्रथम श्रेणी के मान हैं: उन्हें असाइन किया जा सकता है वेरिएबल, अन्य फ़ंक्शंस में पास किए गए, और वापस लौटाए गए। ए क्लोजर एक है फ़ंक्शन शाब्दिक (गुमनाम) जो के वेरिएबल्स को कैप्चर करता है वह वातावरण जिसमें इसे परिभाषित किया गया है।

कार्य शाब्दिक

बिना नाम वाला एक फ़ंक्शन, इनलाइन लिखा हुआ। आप इसे तुरंत कॉल करें या इसे असाइन करें:

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

// invocata immediatamente:
func() { fmt.Println("subito") }()

greet का प्रकार func(string) है।

पर्यावरण पर कब्जा: समापन

फ़ंक्शन लिटरल इसमें दिखाई देने वाले वेरिएबल को पढ़ और संशोधित कर सकता है बाहरी कार्य वापस आने के बाद भी इसका शाब्दिक दायरा:

func counter() func() int {
    n := 0
    return func() int {
        n++
        return n
    }
}

c := counter()
fmt.Println(c(), c(), c())  // 1 2 3

n तब तक "जीवित" रहता है जब तक कम से कम एक समापन इसका संदर्भ देता है। प्रत्येक कॉल के लिए counter() एक नया, स्वतंत्र n बनाता है।

कॉलबैक के रूप में बंद करें

एक बहुत ही सामान्य पैटर्न:

nums := []int{3, 1, 2}
sort.Slice(nums, func(i, j int) bool {
    return nums[i] < nums[j]
})

क्लोजर nums को कैप्चर करता है और ऑर्डर को परिभाषित करता है।

पैरामीटर के रूप में कार्य करता है

किसी फ़ंक्शन को पैरामीटर के रूप में स्वीकार करने के लिए, उसका प्रकार लिखें:

func apply(nums []int, f func(int) int) []int {
    out := make([]int, len(nums))
    for i, n := range nums {
        out[i] = f(n)
    }
    return out
}

double := func(x int) int { return x * 2 }
apply([]int{1, 2, 3}, double)   // [2 4 6]

यदि हस्ताक्षर को पढ़ना कठिन हो जाता है, तो प्रकार उपनाम परिभाषित करें:

type Transform func(int) int
func apply(nums []int, f Transform) []int { ... }

इसे अजमाएं

mk := func() func() int {
    x := 0
    return func() int { x++; return x }
}
a := mk()
b := mk()
fmt.Println(a(), a(), b())

संक्षिप्त

• कार्य प्रथम श्रेणी के हैं: असाइन करने योग्य, पारित करने योग्य, वापस करने योग्य।
• फ़ंक्शन शाब्दिक: func(params) ret { ... }, अनाम।
• क्लोजर: शाब्दिक दायरे के चरों को पकड़ता है, उन्हें जीवित रखता है।
• पैरामीटर में स्पष्ट फ़ंक्शन प्रकार: func(int) int।
• गो 1.22 के बाद से, पुनरावृत्ति के लिए प्रत्येक के पास लूप वेरिएबल की अपनी प्रति है।