Bagaimana untuk menggunakan penutupan dalam Go?

Go ialah bahasa pengaturcaraan moden, pertama kali dilancarkan pada tahun 2009. Ia cekap, ringkas dan sesuai untuk pengaturcaraan serentak, jadi ia menjadi semakin popular dalam pembangunan perisian hari ini. Penutupan ialah fungsi yang sangat penting dalam bahasa Go, yang boleh melaksanakan fungsi dengan mudah seperti pembolehubah fungsi, pengaturcaraan tak segerak dan pengurusan keadaan. Dalam artikel ini, kami akan memperkenalkan cara menggunakan penutupan dalam Go.

1. Definisi penutupan

Penutupan ialah objek fungsi yang boleh merujuk pembolehubah yang ditakrifkan di luar fungsi. Dalam bahasa Go, fungsi boleh dihantar sebagai nilai, jadi fungsi boleh ditakrifkan sebagai pembolehubah. Penutupan ialah fungsi yang ditakrifkan di dalam fungsi Ia boleh mengakses terus pembolehubah fungsi di mana ia berada Walaupun fungsi telah kembali, ia juga boleh mengakses pembolehubah ini melalui penutupan.

2. Pelaksanaan penutupan

Dalam bahasa Go, pelaksanaan penutupan adalah sangat mudah. Berikut ialah kod sampel:

func main() {
    x := 0
    increment := func() int {
        x++
        return x
    }

    fmt.Println(increment())
    fmt.Println(increment())
}

Dalam contoh ini, kami mentakrifkan fungsi penutupan yang dipanggil kenaikan. Ia mempunyai akses kepada pembolehubah x yang ditakrifkan dalam fungsi utama di mana ia berada. Setiap kali fungsi kenaikan dipanggil, ia mengembalikan nilai baru x dan menambah x sebanyak 1. Oleh itu output di atas ialah:

1
2

3. Senario penggunaan penutupan

Penutupan boleh digunakan pada banyak senario yang berbeza. Di bawah ini kami akan memperkenalkan beberapa daripadanya:

1. Pembolehubah fungsi

Sesuatu fungsi boleh ditakrifkan sebagai pembolehubah supaya ia boleh disebarkan dan digunakan secara bebas. Berikut ialah contoh:

func add(x int) func(int) int {
    return func(y int) int {
        return x + y
    }
}

func main() {
    addFive := add(5)
    fmt.Println(addFive(3))
    fmt.Println(addFive(4))
}

Dalam contoh ini, kami mentakrifkan fungsi tambah yang mengembalikan fungsi lain. Fungsi yang dikembalikan boleh mengakses pembolehubah x di dalam fungsi tambah di mana ia berada. Jadi apabila kita memanggil add(5), ia mengembalikan fungsi yang mengambil 5 sebagai nilai x. Kami menyimpan fungsi sebagai addFive dan kemudian boleh menggunakannya untuk melaksanakan operasi penambahan.

2. Pengaturcaraan Asynchronous

Penutupan boleh digunakan dalam fungsi panggil balik dalam pengaturcaraan tak segerak. Berikut ialah contoh:

func fetchData(url string, callback func(string, error)) {
    resp, err := http.Get(url)
    if err != nil {
        callback("", err)
        return
    }

    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        callback("", err)
        return
    }

    callback(string(body), nil)
}

func main() {
    fetchData("https://example.com", func(data string, err error) {
        if err != nil {
            log.Fatal(err)
        }

        fmt.Println(data)
    })
}

Dalam contoh ini, kami mentakrifkan fungsi fetchData, yang boleh secara tak segerak mendapatkan data URL yang ditentukan dan mengembalikan data kepada pemanggil melalui fungsi panggil balik. Fungsi panggil balik ialah penutupan yang boleh merujuk pembolehubah fungsi fetchData secara bebas (seperti URL).

3. Pengurusan Negeri

Penutupan boleh digunakan untuk pengurusan negeri, iaitu, anda boleh mencipta fungsi yang mengemas kini keadaannya sendiri secara automatik setiap kali ia dipanggil. Berikut ialah contoh:

func counter() func() int {
    x := 0
    return func() int {
        x++
        return x
    }
}

func main() {
    cnt := counter()

    fmt.Println(cnt())
    fmt.Println(cnt())
    fmt.Println(cnt())
}

Dalam contoh ini, kami mentakrifkan fungsi pembilang yang mengembalikan fungsi penutupan. Setiap kali fungsi penutupan dipanggil, pembolehubah x ditambah secara automatik sebanyak 1 dan nilai baharu dikembalikan. Jadi outputnya ialah:

1
2
3

Kita boleh menggunakan cara ini untuk mengurus beberapa pembolehubah keadaan, seperti kalkulator, penjana nombor rawak, dsb.

4. Ringkasan

Penutupan ialah ciri yang sangat mudah dalam bahasa Go, yang boleh membantu kami melaksanakan beberapa fungsi pengaturcaraan lanjutan. Dalam artikel ini, kami memperkenalkan definisi, pelaksanaan dan senario penggunaan biasa penutupan. Semoga artikel ini membantu anda lebih memahami dan menggunakan penutupan.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan penutupan dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!