విలువలుగా మూసివేతలు మరియు విధులు

గోలో, ఫంక్షన్‌లు ఫస్ట్-క్లాస్ విలువలు: వాటిని కేటాయించవచ్చు వేరియబుల్స్, ఇతర ఫంక్షన్‌లకు పంపబడ్డాయి మరియు తిరిగి వచ్చాయి. ఒక మూసివేయడం అనేది a ఫంక్షన్ లిటరల్ (అనామక) ఇది ** క్యాప్చర్** యొక్క వేరియబుల్స్ ఇది నిర్వచించబడిన పర్యావరణం.

ఫంక్షన్ అక్షరార్థం

పేరు లేని ఫంక్షన్, ఇన్‌లైన్‌లో వ్రాయబడింది. మీరు వెంటనే కాల్ చేయండి లేదా దానిని కేటాయించండి:

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 నుండి, పునరావృతం కోసం ప్రతి దాని స్వంత లూప్ వేరియబుల్ కాపీని కలిగి ఉంటుంది.