Bagaimanakah fungsi ditakrifkan dalam bahasa Go?

Bahasa Go ialah bahasa pengaturcaraan moden yang dialu-alukan dan digemari oleh ramai pembangun. Sintaksnya ringkas dan jelas, kecekapan pelaksanaannya tinggi, dan ia menyokong pengaturcaraan serentak Ia amat sesuai untuk membina program pelayan berprestasi tinggi dan berkonkurensi tinggi. Sebagai bahasa pengaturcaraan berorientasikan proses, fungsi memainkan peranan penting di dalamnya. Seterusnya, artikel ini akan memperkenalkan cara fungsi dalam bahasa Go ditakrifkan.

1. Takrifan asas fungsi

Dalam bahasa Go, format definisi fungsi adalah seperti berikut:

func function_name(parameters) (return_type) {
    // 函数体
}

Di mana, nama_fungsi mewakili nama fungsi , parameter Mewakili senarai parameter, return_type mewakili jenis nilai pulangan. Perlu diingatkan bahawa parameter dan jenis nilai pulangan bagi fungsi bahasa Go boleh terdiri daripada sebarang jenis, termasuk jenis asas, tatasusunan, struktur, fungsi, dsb.

2. Kaedah hantaran parameter

Terdapat dua cara untuk menghantar parameter dalam fungsi bahasa Go: hantaran nilai dan hantaran rujukan. Dalam kaedah lulus nilai, fungsi menerima salinan parameter; dalam kaedah lulus rujukan, alamat parameter dihantar terus, dan perubahan pada parameter dalam fungsi akan mempengaruhi parameter itu sendiri.

2.1. Kaedah hantaran nilai

Dalam kaedah hantaran nilai, parameter fungsi adalah berdasarkan salinan nilai dan bukannya nilai asal. Lulus parameter berasaskan nilai memastikan bahawa nilai yang dihantar sentiasa kekal tidak berubah dan oleh itu tidak boleh diubah suai. Kaedah ini sesuai untuk hantaran parameter jenis ringkas, seperti int, apungan, rentetan dan jenis hantaran parameter asas yang lain.

func main() {
    a := 5
    b := 10
    swap(a, b) // a 和 b 传递的是值的副本
    fmt.Println(a, b) // 输出 5 10
}
 
func swap(x, y int) int {
    temp := x
    x = y
    y = temp
    return temp
}

Dalam kod di atas, parameter yang diterima oleh pertukaran fungsi adalah salinan nilai, jadi pertukaran x dan y dalam swap tidak akan menjejaskan nilai asal a dan b yang diluluskan dalam panggilan.

2.2. Kaedah hantaran rujukan

Dalam kaedah hantaran rujukan, parameter fungsi menerima alamat atau penunjuk, dan parameter boleh diubah suai secara langsung, dengan itu menukar nilai asal itu sendiri. Kaedah ini sesuai untuk lulus parameter jenis rujukan seperti struktur dan kepingan.

type person struct {
    name string
    age int
}
 
func main() {
    p := person{name: "Tom", age: 20}
    modifyPerson(&p) // 传递 p 的地址
    fmt.Println(p) // 输出 {Jerry 30}
}
 
func modifyPerson(p *person) {
    p.name = "Jerry"
    p.age = 30
}

Dalam kod di atas, fungsi modifyPerson menerima penunjuk kepada struktur orang, dan boleh mengubah suai secara langsung kandungan struktur yang sepadan dengan parameter. Oleh itu, fungsi yang mengubahsuai nilai p mempengaruhi pembolehubah p asal.

3. Parameter pembolehubah dan nilai pulangan berbilang fungsi

Bahasa Go menyokong fungsi yang menghantar bilangan parameter berubah dan menyokong operasi dengan berbilang nilai pulangan.

3.1. Parameter pembolehubah

Jika bilangan parameter fungsi berubah, anda boleh menggunakan sintaks parameter berubah semasa mentakrifkan fungsi. Sintaks variadic menggunakan ... untuk menunjukkan bahawa fungsi menerima pembolehubah bilangan argumen. Fungsi variadik bahasa Go boleh menerima sebarang bilangan parameter, tetapi parameter ini mestilah daripada jenis yang sama.

func sum(nums ...int) int {
    res := 0
    for _, num := range nums {
        res += num
    }
    return res
}
 
func main() {
    fmt.Println(sum(1, 2, 3)) // 输出 6
    fmt.Println(sum(4, 5, 6, 7, 8)) // 输出 30
    fmt.Println(sum()) // 输出 0
}

Dalam kod di atas, parameter jumlah fungsi menggunakan sintaks parameter berubah, yang boleh menerima sebarang bilangan parameter, kemudian tambahkannya dan kembalikan hasilnya.

3.2. Berbilang nilai pulangan

Fungsi dalam bahasa Go boleh mempunyai berbilang nilai pulangan. Pendekatan ini boleh mengurangkan bilangan panggilan fungsi dan meningkatkan kebolehbacaan kod.

func getNames() (string, string) {
    return "Tom", "Jerry"
}
 
func main() {
    firstName, lastName := getNames()
    fmt.Println(firstName, lastName) // 输出 Tom Jerry
}

Dalam kod di atas, fungsi getNames mengembalikan dua nilai jenis rentetan, iaitu Tom dan Jerry. Anda boleh menggunakan berbilang pembolehubah untuk menerima nilai pulangan fungsi apabila anda memanggilnya.

4. Fungsi dan penutupan tanpa nama

Bahasa Go menyokong fungsi dan penutupan tanpa nama. Fungsi tanpa nama ialah fungsi tanpa nama yang boleh ditakrifkan secara langsung dan digunakan apabila diperlukan; penutupan ialah fungsi tanpa nama yang membawa keadaan dan boleh memanggil pembolehubah dalam fungsi, tetapi pembolehubah ini hanya kelihatan di dalam penutupan.

func main() {
    func() {
        fmt.Println("Hello World!")
    }()
 
    add := func(x, y int) int {
        return x + y
    }
    fmt.Println(add(1, 2)) // 输出 3
 
    n := 5
    func() {
        fmt.Println(n+1) // 输出 6
    }()
 
    fmt.Println(n) // 输出 5
}

Dalam kod di atas, fungsi tanpa nama pertama ditakrifkan dan dipanggil terus dalam fungsi utama tanpa nama. Fungsi tanpa nama kedua diberikan kepada tambah pembolehubah dan kemudian boleh dipanggil seperti fungsi biasa. Fungsi tanpa nama ketiga merujuk kepada pembolehubah luaran n supaya n+1 boleh dikeluarkan dengan betul. Memandangkan penutupan membawa keadaan, nilai pembolehubah luaran n tidak akan diubah selepas penutupan dilaksanakan.

Ringkasnya, fungsi dalam bahasa Go adalah blok binaan yang sangat penting. Penggunaan fungsi yang betul membolehkan kami menulis program yang cekap, mudah digunakan dan boleh dibaca. Saya harap artikel ini telah memberi anda pemahaman awal tentang fungsi Go Anda dialu-alukan untuk terus meneroka ciri-ciri fungsi Go secara mendalam dalam pembangunan masa hadapan.

Atas ialah kandungan terperinci Bagaimanakah fungsi ditakrifkan dalam bahasa Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!