Rumah > Artikel > pembangunan bahagian belakang > Penerangan terperinci tentang cara menggunakan fungsi golang
Bahasa Go ialah bahasa pengaturcaraan baharu yang dibangunkan oleh Google Ia ringkas, cekap, mudah dipelajari, dsb., dan sesuai untuk pengaturcaraan serentak. Dalam bahasa Go, fungsi adalah elemen pengaturcaraan yang sangat penting Artikel ini akan memperkenalkan cara menggunakan fungsi golang.
1. Definisi dan panggilan fungsi
Dalam bahasa Go, takrifan fungsi adalah seperti berikut:
func function_name(parameter_list) (result_list) { // 函数代码 }
di mana, function_name
ialah nama fungsi; parameter_list
ialah senarai parameter, berbilang parameter dipisahkan dengan koma; result_list
ialah senarai nilai pulangan fungsi, berbilang nilai pulangan dipisahkan dengan koma di dalam {}
ialah blok kod untuk pelaksanaan fungsi. Sintaks panggilan fungsi
adalah seperti berikut:
function_name(parameter_list)
Contohnya, fungsi mudah sum
ditakrifkan di bawah, yang menerima dua parameter jenis int
dan mengembalikan jumlahnya :
func sum(a int, b int) int { return a + b }
Cara untuk memanggil fungsi sum
adalah seperti berikut:
x := sum(3, 5)
Kod di atas akan mengembalikan nilai 8
dan menetapkannya kepada pembolehubah x
.
2. Berbilang fungsi nilai pulangan
Dalam bahasa Go, fungsi boleh mengembalikan berbilang nilai. Seperti yang ditunjukkan dalam contoh di bawah, fungsi more_return
mengembalikan dua rentetan:
func more_return() (string, string) { return "hello", "world" }
Kaedah panggilan adalah seperti berikut:
a, b := more_return()
Kod di atas akan mengembalikan dua rentetan, Dan tetapkan nilai kepada pembolehubah a
dan b
.
3. Fungsi sebagai parameter
Dalam bahasa Go, fungsi juga boleh dihantar sebagai parameter kepada fungsi lain. Sebagai contoh, contoh berikut menunjukkan fungsi sebagai parameter:
func calc(a int, b int, f func(int, int) int) int { return f(a, b) } func add(a int, b int) int { return a + b } func main() { result := calc(3, 5, add) fmt.Println(result) // 8 }
Dalam kod di atas, fungsi calc
menerima tiga parameter: a
, b
dan fungsi f
, jenisnya masing-masing ialah int
, int
dan func(int, int) int
. Fungsi add
ialah fungsi yang digunakan untuk menambah dua nombor, yang memenuhi keperluan jenis func(int, int) int
. Dalam fungsi main
, fungsi calc
dipanggil untuk mengira nilai penambahan 3
dan 5
, dan fungsi add
dihantar ke fungsi calc
sebagai parameter.
4. Panggilan rekursif bagi fungsi
Dalam bahasa Go, fungsi juga boleh memanggil diri mereka secara rekursif. Sebagai contoh, contoh berikut menunjukkan fungsi yang dipanggil secara rekursif:
func fibonacci(n int) int { if n < 2 { return n } return fibonacci(n-1) + fibonacci(n-2) }
Dalam kod di atas, fungsi fibonacci
menerima integer n
sebagai parameter dan ia mengembalikan n
daripada Urutan Fibonacci 🎜>Nilai nombor. Apabila n
kurang daripada 2, nilai pulangan ialah n
itu sendiri; dalam kes lain, fungsi fibonacci
dipanggil secara rekursif.
5. Fungsi tanpa nama
Dalam bahasa Go, fungsi juga boleh ditakrifkan sebagai fungsi tanpa nama. Fungsi tanpa nama boleh menghantar nilai, memanggil dan kembali seperti fungsi biasa. Contoh berikut menunjukkan penggunaan fungsi tanpa nama untuk mengisih:
package main import "fmt" func main() { a := []int{5, 2, 6, 3, 1, 4} // 使用匿名函数进行排序 sort.Slice(a, func(i, j int) bool { return a[i] < a[j] }) fmt.Println(a) // [1 2 3 4 5 6] }
Dalam kod di atas, kami telah menggunakan fungsi sort.Slice
daripada perpustakaan standard untuk mengisih kepingan. Fungsi tanpa nama perlu dihantar sebagai parameter Senarai parameter bagi fungsi tanpa nama ialah i
dan j
, yang mewakili dua elemen bagi jenis nilai pulangan ialah bool
, yang mewakili elemen mana adalah lebih kecil.
6. Penutupan
Penutupan ialah keseluruhan yang terdiri daripada fungsi dan pembolehubah luaran yang dirujuknya. Dalam bahasa Go, fungsi boleh menjadi penutup. Pembolehubah luaran dalam penutupan dirujuk dalam penutupan, tetapi mempunyai jangka hayat yang berbeza daripada penutupan, dan ia boleh bertahan selepas panggilan penutupan tamat. Contoh berikut menunjukkan cara menggunakan penutupan:
func accumulator() func(int) int { sum := 0 return func(x int) int { sum += x return sum } } func main() { f := accumulator() fmt.Println(f(1)) // 1 fmt.Println(f(2)) // 3 fmt.Println(f(3)) // 6 }
Dalam kod di atas, fungsi accumulator
mengembalikan fungsi tanpa nama dan pembolehubah sum
dirujuk dalam fungsi tanpa nama. Selepas panggilan penutupan tamat, pembolehubah sum
masih wujud dan terus mengekalkan nilainya. Dalam fungsi main
, kami memanggil fungsi accumulator
untuk mendapatkan fungsi penutupan f
dan mengira jumlah terkumpul dengan memanggil fungsi f
beberapa kali.
7. Ringkasan
Fungsi dalam bahasa Go ialah elemen pengaturcaraan yang sangat penting, ia mudah, cekap, mudah dipelajari, dsb., dan fungsi sokongan sebagai parameter, nilai pulangan berbilang dan rekursi. Panggilan, fungsi tanpa nama, penutupan dan banyak ciri lain. Menguasai penggunaan ciri ini boleh membantu kami menyelesaikan kerja pembangunan bahasa Go dengan lebih baik.
Atas ialah kandungan terperinci Penerangan terperinci tentang cara menggunakan fungsi golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!