Il existe plusieurs portées pour les variables de langage Go

Les variables du langage Go ont deux portées : 1. Les variables locales sont des variables déclarées au niveau de la fonction et au niveau du bloc ; les variables locales ne sont accessibles que dans leurs blocs ou fonctions, et les variables locales déclarées ne peuvent pas être dans le même bloc ou redéclarées dans un fonction. 2. Les variables globales sont des variables déclarées au niveau du package ; les variables globales sont disponibles tout au long du cycle de vie du programme et les variables globales ne peuvent pas être déclarées à l'aide de l'opérateur ":=".

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

L'emplacement des déclarations de variables

Il existe trois niveaux de déclarations de variables dans le langage Go :

• Niveau package : les variables sont déclarées en dehors de la fonction
• Niveau fonction : les variables sont à l'intérieur de la fonction, y compris les paramètres de la fonction Paramètre variables, mais déclarées en dehors du bloc de code
• Niveau de bloc : il existe deux types de ceci, l'un est explicite, utilisant du code entre accolades {} ; l'autre est implicite, comme l'initialisation après une expression for ou if.

Exemple d'emplacement de variable

package main

import "fmt"

var test = "test"  //在函数外，包级别变量

func main() {
    a, b := 1, 2  //a和b，c在main函数内定义，函数级别变量
    c := sum(a, b)
    fmt.Println(c)
    fmt.Println(test)

    for i := 0; i < 10; i++ {   //i为for循环内定义，为隐式块级别变量
        var d = i + 1    //d在for的循环体内，以大括号{}括起来，为显式块级别变量
        fmt.Println(d)
    }

}

func sum(a, b int) int {   //函数参数a和b，在函数内定义，为函数级别变量
    fmt.Println(a)
    fmt.Println(b)
    nu := a + b
    return nu
}

Portée de la variable

L'emplacement d'une déclaration de variable détermine l'endroit où l'accès à la variable est autorisé et la période de déclaration de la variable. La plage accessible d'une variable est appelée la portée de la variable. Dans le langage Go, la portée des variables est divisée en deux catégories :

• variables locales, également appelées variables locales
• variables globales

variables locales

Les variables déclarées au niveau de la fonction et au niveau du bloc sont des variables locales . Les variables locales ont les caractéristiques suivantes :

• Les variables locales ne sont accessibles que dans leur bloc ou leur fonction.
• Les variables locales ne vivent que jusqu'à la fin du bloc ou de la fonction dans laquelle elles sont déclarées. Ils sont ensuite recyclés par le éboueur.
• Les variables locales qui ont été déclarées ne peuvent pas être redéclarées dans le même bloc ou fonction.

Exemple :

package main

import "fmt"

func main() {
    var a= "astrng"
    fmt.Println(a)
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }
    fmt.Println(i)
}

func testLocal() {
    fmt.Println(a)
}

Ce code signalera une erreur lors de la compilation :

undefined: i
undefined: a

Cause :

i : Il s'agit d'une variable locale de niveau bloc dans le corps de la boucle for lorsqu'elle est accessible en dehors de la boucle for où elle est définie. , non défini sera signalé.

a : Il s'agit d'une variable locale au niveau de la fonction principale. Elle n'est pas accessible dans la fonction testLocal et une erreur non définie sera signalée.

Variables globales

Les variables déclarées au niveau du package sont des variables globales. Les variables globales ont les caractéristiques suivantes :

• Lorsqu'une variable globale commence par une minuscule, cette variable globale ne peut être utilisée qu'au sein du package dans lequel elle est définie. Autrement dit, les variables sont visibles dans le package.
• Lorsqu'une variable globale commence par une lettre majuscule, cette variable globale peut être utilisée dans différents packages. Autrement dit, la variable est visible partout.
• Les variables globales sont disponibles tout au long du cycle de vie du programme.
• Les variables globales ne peuvent pas être déclarées à l'aide de l'opérateur :=.

package main

import "fmt"

var a = "astring"

func main() {
    testGlobal()
}

func testGlobal() {
    fmt.Println(a)  //运行结果是，正确打印出a的值“astring”
}

Les variables locales et les variables globales ont le même nom

Les variables globales et les variables locales dans les programmes en langage Go peuvent avoir le même nom, mais les variables locales dans le corps de la fonction auront la priorité.

package main
import "fmt"
//声明全局变量
var a float32 = 3.14
func main() {
    //声明局部变量
    var a int = 3
    fmt.Printf("a = %d\n", a)
}

Les résultats d'exécution sont les suivants :

a = 3

Le langage Go exécute des variables locales et des variables globales du même nom. La variable du même nom est dans la portée locale et elle masquera les variables dans la portée externe.

package main

import "fmt"

var a = "globala"

func main() {
    var a = "locala"
    fmt.Println(a)  //此处的a会遮蔽外面定义的a全局变量，输出locala
}
func testGlobal() {
  fmt.Println(a)  //此处是全局变量a，输出globala
}

【Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation】

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!