மூடல்கள் மற்றும் செயல்பாடுகள் மதிப்புகளாக

Go இல், செயல்பாடுகள் முதல் வகுப்பு மதிப்புகள்: அவை ஒதுக்கப்படலாம் மாறிகள், பிற செயல்பாடுகளுக்கு அனுப்பப்பட்டு, திரும்பியது. ஒரு மூடுதல் என்பது 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 முதல், ஒவ்வொரு மறு செய்கைக்கும் அதன் சொந்த லூப் மாறியின் நகல் உள்ளது.