Teilen Sie Qualitätshinweise: Erfahren Sie, wie Sie Go-Verschlüsse verwenden

Die folgende Tutorial-Kolumne von go-Sprache führt Sie in das Erlernen und Verwenden von Go-Verschlüssen ein. Ich hoffe, dass es für Freunde hilfreich ist, die es benötigen!

                                                                                                                ​ ​ ​ ​ ​ ​ ​ ​ ​

go-Abschlüsse

In Golang ist ein Abschluss eine Funktion, die auf Variablen außerhalb ihres Gültigkeitsbereichs verweisen kann.
Mit anderen Worten, ein Abschluss ist eine innere Funktion, die Zugriff auf Variablen innerhalb des Bereichs hat, in dem sie erstellt wurde. Selbst wenn die externe Funktion die Ausführung abschließt und der Bereich zerstört wird, kann weiterhin auf sie zugegriffen werden.
Bevor Sie sich mit Schließungen befassen, müssen Sie verstehen, was anonyme Funktionen sind.

Anonyme Funktion

Wie der Name schon sagt, ist eine anonyme Funktion eine Funktion ohne Namen.
Zum Beispiel erstellen wir eine allgemeine Funktion und eine anonyme Funktion

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()}

Die Ergebnisausgabe:

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

Verwenden Sie anonyme Funktionen, indem Sie eine Funktion erstellen, die eine Funktion zurückgibt.

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

Ergebnisausgabe:

hello golang

Der einzige Unterschied zwischen regulären Funktionen und anonymen Funktionen besteht darin, dass anonyme Funktionen nicht auf Paketebene deklariert werden, sondern dynamisch deklariert werden und normalerweise entweder verwendet, vergessen oder einer Variablen zur späteren Verwendung zugewiesen werden .

Die Essenz des Abschlusses

Ein Abschluss ist ein Codeblock, der freie Variablen enthält, die nicht innerhalb dieses Codeblocks oder in einem globalen Kontext definiert sind, sondern in der Umgebung definiert sind, in der der Codeblock definiert ist . Da die freien Variablen im Codeblock enthalten sind, werden diese freien Variablen und die Objekte, auf die sie verweisen, nicht freigegeben, solange der Abschluss noch verwendet wird. Der auszuführende Code stellt eine gebundene Rechenumgebung für die freien Variablen bereit.
Der Wert von Abschlüssen besteht darin, dass sie als Funktionsobjekte oder anonyme Funktionen verwendet werden können. Für das Typsystem bedeutet dies, dass sie nicht nur Daten, sondern auch Code darstellen. Die meisten Sprachen, die Abschlüsse unterstützen, verwenden Funktionen als Objekte der ersten Ebene, was bedeutet, dass diese Funktionen in Variablen gespeichert und als Parameter an andere Funktionen übergeben werden können. Das Wichtigste ist, dass sie von Funktionen dynamisch erstellt und zurückgegeben werden können.

Abschlüsse in Golang verweisen auch auf Variablen außerhalb der Funktion. Die Implementierung von Abschlüssen stellt sicher, dass die durch den Abschluss referenzierten Variablen immer vorhanden sind, solange der Abschluss noch verwendet wird. Formal sind anonyme Funktionen Abschlüsse.
Sehen wir uns ein Abschlussbeispiel an:

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())}

Ergebnisausgabe:

1
2
3

In diesem Beispiel sind aufgerufen und sum freie Variablen. Die von der Aufruferfunktion zurückgegebene anonyme Funktion stellt eine Rechenumgebung für die freien Variablen bereit von anonymen Funktionen und freien Variablen Blöcke sind eigentlich Abschlüsse. In der Abschlussfunktion können nur anonyme Funktionen auf die aufgerufenen und summierten freien Variablen zugreifen, jedoch nicht auf andere Weise darauf zugreifen, sodass die freien Variablen des Abschlusses sicher sind.
Gemäß den Regeln imperativer Sprachen gibt die aufrufende Funktion nur die Adresse der anonymen Funktion zurück. Wenn die anonyme Funktion jedoch ausgeführt wird, tritt ein Fehler auf, da die Summe und die aufgerufenen Variablen nicht in ihrem Gültigkeitsbereich gefunden werden können. Wenn in funktionalen Sprachen ein eingebetteter Funktionskörper auf eine Variable außerhalb des Körpers verweist, werden die an der Definition beteiligte Referenzumgebung und der Funktionskörper in ein Ganzes gepackt (Abschluss) und zurückgegeben. Die Verwendung von Abschlüssen unterscheidet sich nicht von normalen Funktionsaufrufen.

Jetzt geben wir die Definition einer Referenzumgebung an: eine Menge aller aktiven Einschränkungen zu einem bestimmten Zeitpunkt in der Programmausführung. Die Einschränkungen beziehen sich auf die Beziehung zwischen dem Namen einer Variablen und dem Objekt, das sie darstellt.
Wir sagen also: Abschluss = Funktion + Referenzumgebung

Tatsächlich können wir die Abschlussfunktion als Klasse betrachten (C++). Ein Abschlussfunktionsaufruf dient dazu, ein Objekt zu instanziieren, und die freien Variablen des Abschlusses sind die Mitgliedsvariablen der Klasse sind die Parameter der Abschlussfunktion die Parameter des Funktionsobjekts der Klasse. In diesem Beispiel kann next als instanziiertes Objekt und next () als Rückgabewert des Objektfunktionsaufrufs betrachtet werden.
Das erinnert uns an ein berühmtes Sprichwort: Objekte sind Daten mit Verhalten, und Abschlüsse sind Verhaltensweisen mit Daten.

Einige Beispiele für die Verwendung von Abschlüssen.

• Verwenden Sie Abschlüsse, um Datenisolation zu erreichen. Angenommen, Sie möchten eine Funktion erstellen die auf Daten zugreifen kann, die auch nach Beendigung der Funktion bestehen bleiben. Wenn Sie beispielsweise zählen möchten, wie oft eine Funktion aufgerufen wurde, aber nicht möchten, dass jemand anderes Zugriff auf diese Daten hat (damit diese nicht versehentlich geändert werden), können Sie dies mit einem Abschluss tun:
  

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())}

Ergebnisausgabe:

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过程，否则会导致当前进程的异常退出，而这并不是我们所期望的。

                                      

Das obige ist der detaillierte Inhalt vonTeilen Sie Qualitätshinweise: Erfahren Sie, wie Sie Go-Verschlüsse verwenden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!