La relation entre la fermeture de la fonction Golang et la portée de la variable locale

Réponse : les fermetures dans Go peuvent accéder à des variables en dehors de la portée de leur définition, même si ces variables sont en dehors de la portée de la fonction. Description détaillée : La portée d'une variable locale est limitée à la fonction ou au bloc dans lequel elle est déclarée. Les fermetures contiennent du code de fonction et des références aux variables de portée environnantes. Les fermetures peuvent accéder aux variables dans la portée externe même après que la fonction externe a terminé son exécution. Les fermetures sont utiles dans les scénarios où l'état doit être mémorisé, comme dans le cas des compteurs.

La relation entre les fermetures de fonctions Go et les portées de variables locales

Dans Go, une fermeture est une fonction spéciale qui lie une fonction aux variables dans sa portée environnante. En utilisant des fermetures, une fonction peut accéder à des variables en dehors de sa portée de définition, même si ces variables sont en dehors de la portée de la définition de la fonction.

Portée de la variable locale

La portée d'une variable locale est limitée à la fonction ou au bloc dans lequel elle est déclarée. Cela signifie que ces variables ne sont pas visibles par les autres codes en dehors de la fonction ou du bloc. Par exemple :

func example() {
  x := 10 // 局部变量，仅在 example 函数中可见
}

Fermetures

Une fermeture est essentiellement une fonction qui contient non seulement son propre code, mais également des références à des variables dans sa portée environnante. Par exemple :

func outer() {
  x := 10

  inner := func() {
    fmt.Println(x) // 这里的 x 引用了 outer 函数中声明的变量
  }

  return inner
}

Dans l'exemple ci-dessus, la fonction inner est une fermeture car elle fait référence à x dans sa variable de fonction externe environnante. Même une fois l'exécution de la fonction outer terminée, la fonction intérieure peut toujours accéder à la variable x. inner 函数是一个闭包，因为它引用了其周围 outer 函数中的 x 变量。即使 outer 函数执行完毕，inner 函数仍然可以访问 x 变量。

实战案例

以下是一个使用闭包的实际案例：

package main

import "fmt"

func main() {
  incrementer := func() int {
    var counter int
    return func() int {
      counter++
      return counter
    }
  }()

  fmt.Println(incrementer()) // 输出：1
  fmt.Println(incrementer()) // 输出：2
  fmt.Println(incrementer()) // 输出：3
}

在这个例子中，incrementer 函数返回一个闭包，该闭包引用了局部变量 counter。每次调用闭包时，counter

🎜Cas pratique🎜🎜🎜Ce qui suit est un cas pratique d'utilisation de fermetures : 🎜rrreee🎜Dans cet exemple, la fonction incrementer renvoie une fermeture qui référence la variable locale compteur. A chaque appel de la fermeture, le counter est incrémenté, implémentant ainsi la fonction d'un compteur. 🎜

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!