Partager des notes de qualité : découvrez comment utiliser les fermetures Go

La colonne tutorielle suivante de go language vous présentera l'apprentissage et l'utilisation des fermetures go. J'espère qu'elle sera utile aux amis qui en ont besoin !

                                                                                                            ​ ​ ​ ​ ​ ​ ​

go Closures

Dans Golang, une fermeture est une fonction qui peut référencer des variables en dehors de sa portée.
En d'autres termes, une fermeture est une fonction interne qui a accès aux variables dans le cadre dans lequel elle a été créée. Même si la fonction externe termine son exécution et que la portée est détruite, elle reste accessible.
Avant de vous plonger dans les fermetures, vous devez comprendre ce que sont les fonctions anonymes.

Fonction anonyme

Comme son nom l'indique, une fonction anonyme est une fonction sans nom.
Par exemple, nous créons une fonction générale et une fonction anonyme

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

Le résultat :

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

Utilisez des fonctions anonymes en créant une fonction qui renvoie une fonction.

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

Résultat :

hello golang

La seule différence entre les fonctions normales et les fonctions anonymes est que les fonctions anonymes ne sont pas déclarées au niveau du package, elles sont déclarées dynamiquement et sont généralement soit utilisées, oubliées ou affectées à une variable pour une utilisation ultérieure. .

L'essence de la fermeture

Une fermeture est un bloc de code qui contient des variables libres qui ne sont pas définies dans ce bloc de code ou dans un contexte global, mais sont définies dans l'environnement dans lequel le bloc de code est défini . Puisque les variables libres sont contenues dans le bloc de code, ces variables libres et les objets auxquels elles font référence ne seront pas libérés tant que la fermeture est toujours utilisée. Le code à exécuter fournit un environnement informatique lié pour les variables libres.
La valeur des fermetures est qu'elles peuvent être utilisées comme objets de fonction ou fonctions anonymes. Pour le système de types, cela signifie représenter non seulement des données mais aussi du code. La plupart des langages prenant en charge les fermetures utilisent des fonctions comme objets de premier niveau, ce qui signifie que ces fonctions peuvent être stockées dans des variables et transmises en tant que paramètres à d'autres fonctions. Le plus important est qu'elles puissent être créées et renvoyées dynamiquement par les fonctions.

Les fermetures dans Golang feront également référence à des variables en dehors de la fonction. L'implémentation des fermetures garantit que tant que la fermeture est toujours utilisée, les variables référencées par la fermeture existeront toujours. Formellement, les fonctions anonymes sont des fermetures.
Jetons un coup d'œil à un exemple de fermeture :

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

Sortie du résultat :

1
2
3

Dans cet exemple, appelée et sum sont des variables libres. La fonction anonyme renvoyée par la fonction appelante fournit un environnement informatique pour les variables libres. de fonctions anonymes et de variables libres. Les blocs sont en réalité des fermetures. Dans la fonction de fermeture, seules les fonctions anonymes peuvent accéder aux variables libres appelées et additionnées, mais ne peuvent pas y accéder par d'autres moyens, les variables libres de fermeture sont donc sécurisées.
Selon les règles des langages impératifs, la fonction appelante ne renvoie que l'adresse de la fonction anonyme, mais lorsque la fonction anonyme est exécutée, une erreur se produira car la somme et les variables appelées sont introuvables dans sa portée. Dans les langages fonctionnels, lorsqu'un corps de fonction intégré fait référence à une variable en dehors du corps, l'environnement de référence et le corps de fonction impliqués dans la définition seront regroupés dans un tout (fermeture) et renvoyés. L'utilisation de fermetures n'est pas différente des appels de fonction normaux.

Nous donnons maintenant la définition de l'environnement de référence : un ensemble de toutes les contraintes actives à un certain moment de l'exécution du programme. Les contraintes font référence à la relation entre le nom d'une variable et l'objet qu'elle représente.
On dit donc : fermeture = fonction + environnement de référence

En fait, on peut considérer la fonction de fermeture comme une classe (C++). Un appel de fonction de fermeture consiste à instancier un objet, et les variables libres de la fermeture sont les variables membres. de la classe. , les paramètres de la fonction de fermeture sont les paramètres de l'objet fonction de la classe. Dans cet exemple, next peut être considéré comme un objet instancié et next() peut être considéré comme la valeur de retour de l'appel de fonction objet.
Cela nous rappelle un dicton célèbre : les objets sont des données avec un comportement, et les fermetures sont des comportements avec des données.

Quelques exemples d'utilisation des fermetures

• Utilisez des fermetures pour obtenir l'isolation des données
  Supposons que vous souhaitiez créer une fonction. qui peut accéder aux données qui persistent même après la sortie de la fonction. Par exemple, si vous souhaitez compter le nombre de fois qu'une fonction a été appelée, mais que vous ne voulez pas que quelqu'un d'autre ait accès à ces données (afin qu'ils ne les modifient pas accidentellement), vous pouvez le faire avec une fermeture :

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

Résultat :

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

                                      

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!