Kongsi nota kualiti: Ketahui cara menggunakan penutupan go

Berikut adalah pengenalan kepada pembelajaran dan penggunaan penutupan go daripada ruangan tutorial go Saya harap ia dapat membantu rakan yang memerlukan.

                                                                                                               

pergi penutupan

Di Golang, penutupan ialah Fungsi pada pembolehubah di luar skop.
Dalam erti kata lain, penutupan ialah fungsi dalaman yang mempunyai akses kepada pembolehubah dalam skop di mana ia dicipta. Walaupun fungsi luaran menyelesaikan pelaksanaan dan skop dimusnahkan, ia masih boleh diakses.
Sebelum mendalami penutupan, anda perlu memahami apa itu fungsi tanpa nama.

Fungsi tanpa nama

Seperti namanya, fungsi tanpa nama ialah fungsi tanpa nama.
Sebagai contoh, kami mencipta fungsi umum dan fungsi tanpa nama

package mainimport (
    "fmt")func sayhi1() { // 一般函数
    fmt.Println("hello golang, I am Regular function")}func main() {
    sayhi1()
    sayhi2 := func() { //匿名函数
        fmt.Println("hello golang, I am Anonymous function")
    }
    sayhi2()}

Output hasil:

hello golang, I am Regular functionhello golang, I am Anonymous function

Gunakan fungsi tanpa nama dengan mencipta fungsi yang mengembalikan fungsi.

package mainimport (
    "fmt")func sayhello(s string) func() {
    return func() {
        fmt.Println("hello", s)
    }}func main() {
    sayhello := sayhello("golang")
    sayhello()}

Output hasil:

hello golang

Satu-satunya perbezaan antara fungsi biasa dan fungsi tanpa nama ialah fungsi tanpa nama tidak diisytiharkan pada peringkat pakej, ia diisytiharkan secara dinamik dan biasanya sama ada digunakan atau dilupakan, atau diperuntukkan kepada pembolehubah untuk kegunaan kemudian.

Sifat Penutupan

Penutupan ialah blok kod yang mengandungi pembolehubah bebas yang tidak berada dalam blok kod ini atau mana-mana konteks global ditakrifkan, tetapi dalam persekitaran di mana blok kod ditakrifkan. Oleh kerana pembolehubah bebas terkandung dalam blok kod, pembolehubah bebas ini dan objek yang dirujuknya tidak akan dikeluarkan selagi penutupan masih digunakan Kod yang akan dilaksanakan menyediakan persekitaran pengkomputeran terikat untuk pembolehubah bebas.
Nilai penutupan ialah ia boleh digunakan sebagai objek fungsi atau fungsi tanpa nama Untuk sistem jenis, ini bermakna mewakili bukan sahaja data tetapi juga kod. Kebanyakan bahasa yang menyokong penutupan menggunakan fungsi sebagai objek peringkat pertama, yang bermaksud bahawa fungsi ini boleh disimpan dalam pembolehubah dan dihantar sebagai parameter kepada fungsi lain Perkara yang paling penting ialah ia boleh dibuat secara dinamik dan dikembalikan oleh fungsi.

Penutupan di Golang juga akan merujuk pembolehubah di luar fungsi Pelaksanaan penutupan memastikan bahawa selagi penutupan masih digunakan, pembolehubah yang dirujuk oleh penutupan akan sentiasa wujud. Secara rasmi, fungsi tanpa nama adalah penutupan.
Mari kita lihat contoh penutupan:

package mainimport (
    "fmt")func caller() func() int {
    callerd := 1
    sum := 0
    return func() int {
        sum += callerd        return sum    }}func main() {
    next := caller()
    fmt.Println(next())
    fmt.Println(next())
    fmt.Println(next())}

Output hasil:

1
2
3

Dalam contoh ini, dipanggil dan jumlah ialah pembolehubah bebas, dan fungsi tanpa nama dikembalikan oleh pemanggil fungsi adalah percuma Pembolehubah menyediakan persekitaran pengkomputeran, dan blok kod yang terdiri daripada fungsi tanpa nama dan pembolehubah bebas sebenarnya adalah penutup. Dalam fungsi penutupan, hanya fungsi tanpa nama boleh mengakses pembolehubah bebas yang dipanggil dan jumlah, tetapi tidak boleh mengaksesnya melalui cara lain, jadi pembolehubah bebas penutupan adalah selamat.
Mengikut peraturan bahasa imperatif, fungsi pemanggil hanya mengembalikan alamat fungsi tanpa nama, tetapi apabila fungsi tanpa nama dilaksanakan, ralat akan berlaku kerana jumlah dan pembolehubah yang dipanggil tidak boleh ditemui dalam skopnya. Dalam bahasa berfungsi, apabila badan fungsi terbenam merujuk pembolehubah di luar badan, persekitaran rujukan dan badan fungsi yang terlibat dalam definisi akan dibungkus menjadi keseluruhan (penutupan) dan dikembalikan. Penggunaan penutupan tidak berbeza daripada panggilan fungsi biasa.

Kini kami memberikan definisi persekitaran rujukan: set semua kekangan aktif pada titik tertentu dalam pelaksanaan program, di mana kekangan merujuk kepada nama pembolehubah dan objek yang diwakilinya.
Jadi kita katakan: penutupan = persekitaran rujukan fungsi

Malah, kita boleh memikirkan fungsi penutupan sebagai kelas (C Panggilan fungsi penutupan adalah untuk membuat instantiat objek, dan pembolehubah bebas penutupan Mereka adalah pembolehubah ahli kelas, dan parameter fungsi penutupan ialah parameter objek fungsi kelas. Dalam contoh ini, next boleh dianggap sebagai objek instantiated, dan next() boleh dianggap sebagai nilai pulangan bagi panggilan fungsi objek.
Ini mengingatkan kita tentang pepatah terkenal: Objek ialah data dengan gelagat dilampirkan, dan penutupan ialah gelagat dengan data dilampirkan

Beberapa contoh penggunaan penutupan

• Memanfaatkan Penutupan untuk Pengasingan Data
  Andaikan anda ingin mencipta fungsi yang boleh mengakses data yang berterusan walaupun selepas fungsi keluar. Sebagai contoh, jika anda ingin mengira bilangan kali fungsi telah dipanggil, tetapi tidak mahu orang lain mempunyai akses kepada data tersebut (supaya mereka tidak mengubahnya secara tidak sengaja), anda boleh melakukannya dengan penutupan:

package mainimport (
    "fmt")func caller() func() int {
    callerd := 0
    return func() int {
        callerd++
        return callerd    }}func main() {
    next := caller()
    fmt.Println(next())
    fmt.Println(next())
    fmt.Println(next())}

Keluaran hasil:

1
2
3

• 利用闭包包装函数和创建中间件
  Go 中的函数是一等公民。这意味着您不仅可以动态创建匿名函数，还可以将函数作为参数传递给函数。例如，在创建 Web 服务器时，通常会提供一个功能来处理Web 请求到特定的路由。

package mainimport (
  "fmt"
  "net/http")func main() {
  http.HandleFunc("/hello", hello)
  http.ListenAndServe(":3000", nil)}func hello(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintln(w, "<h1>Hello!</h1>")}

在上面例子中，函数 hello() 被传递给 http.HandleFunc() 函数，并在该路由匹配时调用。
虽然这段代码不需要闭包，但如果我们想用更多逻辑包装我们的处理程序，闭包是非常有用的。一个完美的例子是我们可以通过创建中间件来在我们处理程序执行之前或之后做一些其它的工作。
什么是中间件？
中间件基本上是可重用功能的一个奇特术语，它可以在设计用于处理 Web 请求的代码之前和之后运行代码。在 Go 中，这些通常是通过闭包来实现的，但在不同的编程语言中，可以通过其他方式来实现。
在编写 Web 应用程序时使用中间件很常见，而且它们不仅可用于计时器（您将在下面看到一个示例）。例如，中间件可用于编写代码验证用户是否登录过一次，然后将其应用到你的所有会员专页。
让我们看看一个简单的计时器中间件在 Go 中是如何工作的。

package mainimport (
  "fmt"
  "net/http"
  "time")func main() {
  http.HandleFunc("/hello", timed(hello))
  http.ListenAndServe(":3000", nil)}func timed(f func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
  return func(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    f(w, r)
    end := time.Now()
    fmt.Println("The request took", end.Sub(start))
  }}func hello(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintln(w, "<h1>Hello!</h1>")}

timed() 函数接受一个可以用作处理函数的函数，并返回一个相同类型的函数，但返回的函数与传递它的函数不同。返回的闭包记录当前时间，调用原始函数，最后记录结束时间并打印出请求的持续时间。同时对我们的处理程序函数内部实际发生的事情是不可知的。
现在我们要做的就是将我们的处理程序包装在 timed(handler) 中并将闭包传递给 http.HandleFunc() 函数调用。

• 利用闭包使用 sort 二分搜索
  使用标准库中的包也经常需要闭包，例如 sort 包。这个包为我们提供了大量有用的功能和代码，用于排序和搜索排序列表。例如，如果您想对一个整数切片进行排序，然后在切片中搜索数字 7，您可以像这样使用 sort 包。

package mainimport (
  "fmt"
  "sort")func main() {
  numbers := []int{1, 11, -5, 7, 2, 0, 12}
  sort.Ints(numbers)
  fmt.Println("Sorted:", numbers)
  index := sort.SearchInts(numbers, 7)
  fmt.Println("7 is at index:", index)}

结果输出：

Sorted: [-5 0 1 2 7 11 12]7 is at index: 4

如果要搜索的每个元素都是自定义类型的切片会发生什么？或者，如果您想找到第一个等于或大于 7 的数字的索引，而不仅仅是 7 的第一个索引？
为此，您可以使用 sort.Search() 函数，并且您需要传入一个闭包，该闭包可用于确定特定索引处的数字是否符合您的条件。
sort.Search() is a binary search
sort.Search 函数执行二分搜索，因此它需要一个闭包，该闭包在满足您的条件之前对任何索引返回 false，在满足后返回 true。
让我们使用上面描述的示例来看看它的实际效果；我们将搜索列表中第一个大于或等于 7 的数字的索引。

package mainimport (
    "fmt"
    "sort")func main() {
    numbers := []int{1, 11, -5, 8, 2, 0, 12}
    sort.Ints(numbers)
    fmt.Println("Sorted:", numbers)

    index := sort.Search(len(numbers), func(i int) bool {
        return numbers[i] >= 7
    })
    fmt.Println("The first number >= 7 is at index:", index)
    fmt.Println("The first number >= 7 is:", numbers[index])}

结果输出：

Sorted: [-5 0 1 2 8 11 12]The first number >= 7 is at index: 4
The first number >= 7 is: 8

在这个例子中，我们的闭包是作为第二个参数传递给 sort.Search() 的简单函数。
这个闭包访问数字切片，即使它从未被传入，并为任何大于或等于 7 的数字返回 true。通过这样做，它允许 sort.Search() 工作而无需了解什么您使用的基础数据类型是什么，或者您试图满足什么条件。它只需要知道特定索引处的值是否符合您的标准。

• 用闭包+defer进行处理异常

package mainimport (
    "fmt")func handle() {
    defer func() {
        err := recover()
        if err != nil {
            fmt.Println("some except had happend:", err)
        }
    }()
    var a *int = nil
    *a = 100}func main() {
    handle()}

结果输出：

some except had happend: runtime error: invalid memory address or nil pointer dereference

recover函数用于终止错误处理流程。一般情况下，recover应该在一个使用defer关键字的函数中执行以有效截取错误处理流程。如果没有在发生异常的goroutine中明确调用恢复过程（调用recover函数），会导致该goroutine所属的进程打印异常信息后直接退出
对于第三方库的调用，在不清楚是否有panic的情况下，最好在适配层统一加上recover过程，否则会导致当前进程的异常退出，而这并不是我们所期望的。

                                      

Atas ialah kandungan terperinci Kongsi nota kualiti: Ketahui cara menggunakan penutupan go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!