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!