Pengenalan kepada ciri lanjutan fungsi Golang

Ciri fungsi Golang lanjutan: Penutupan: Tangkap pembolehubah dalam skop sekeliling untuk menghantar data. Fungsi Variadic: menerima bilangan parameter yang berubah-ubah. Fungsi tanpa nama: tidak dinamakan, panggil balik sekali atau penutupan. Fungsi tertib lebih tinggi: menerima atau mengembalikan parameter fungsi. Generik: Fungsi universal, terpakai pada jenis data yang berbeza (diperkenalkan dalam Go 1.18).

Ciri Lanjutan Fungsi Golang

Fungsi ialah cara yang berkuasa untuk mengatur kod anda. Fungsi Go menyediakan satu set ciri lanjutan yang membantu anda menulis kod yang lebih modular dan boleh diselenggara. Artikel ini akan memperkenalkan beberapa ciri lanjutan yang berguna dan menunjukkan aplikasinya melalui kes praktikal.

Penutupan

Penutupan ialah fungsi yang menangkap pembolehubah skop fungsi sekeliling. Ia membolehkan anda mengakses pembolehubah ini selepas fungsi tersebut dilaksanakan. Ini berguna apabila anda perlu menghantar data ke fungsi bersarang atau panggil balik.

func outer() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    f := outer()
    fmt.Println(f()) // 1
    fmt.Println(f()) // 2
}

Fungsi Variadik

Fungsi variadik membolehkan anda memasukkan bilangan parameter yang berubah-ubah. Ini berguna apabila anda perlu memproses data daripada sumber yang berbeza.

func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

func main() {
    fmt.Println(sum(1, 2, 3, 4, 5)) // 15
}

Fungsi tanpa nama

Fungsi tanpa nama ialah fungsi tanpa nama yang tidak mempunyai penerima yang jelas. Ia sering digunakan untuk mentakrifkan panggilan balik atau penutupan sekali dengan mudah.

func main() {
    // 定义一个匿名函数并传递给 sort.Slice
    sort.Slice([]int{1, 3, 2}, func(i, j int) bool {
        return []int{1, 3, 2}[i] < []int{1, 3, 2}[j]
    })
}

Fungsi Susunan Tinggi

Fungsi tertib lebih tinggi ialah fungsi yang mengambil fungsi sebagai parameter atau mengembalikan fungsi. Ini membolehkan anda membina kod yang lebih fleksibel dan boleh disesuaikan pada masa jalan.

func add10(x int) int {
    return x + 10
}

func mapValues(nums []int, f func(int) int) []int {
    result := make([]int, len(nums))
    for i, num := range nums {
        result[i] = f(num)
    }
    return result
}

func main() {
    nums := []int{1, 2, 3, 4, 5}
    fmt.Println(mapValues(nums, add10)) // [11 12 13 14 15]
}

Generics

Generik membolehkan anda menulis fungsi yang berfungsi secara meluas merentas jenis data yang berbeza. Generik telah diperkenalkan dalam Go 1.18.

func max[T comparable](a, b T) T {
    if a > b {
        return a
    }
    return b
}

func main() {
    fmt.Println(max(1, 2)) // 2
    fmt.Println(max("hello", "world")) // world
}

Ini adalah beberapa ciri lanjutan fungsi Golang. Ciri ini boleh meningkatkan kecekapan pengaturcaraan dan kualiti kod anda dengan menyediakan sokongan untuk penutupan, fungsi variadik, fungsi tanpa nama, fungsi tertib tinggi dan generik.

Atas ialah kandungan terperinci Pengenalan kepada ciri lanjutan fungsi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!