Que sont les variables en langage Go

Dans le langage Go, une variable est un montant dont le contenu peut changer (modifier) ​​lors de l'exécution du programme ; une variable est l'unité de base du programme et représente un espace de stockage de données dans la mémoire. trouvé via le nom de la variable. La fonction des variables est de stocker les données utilisateur. C'est un concept abstrait en langage informatique qui peut stocker des résultats de calcul ou représenter des valeurs.

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

1. Présentation

Une variable (Variable) est la quantité que le contenu peut changer (modifier) ​​pendant l'exécution du programme. Une variable est l'unité de base du programme et une représentation d'un stockage de données ; espace dans la mémoire. Il peut être transmis Le nom de la variable trouve la valeur de la variable.

La fonction des variables est de stocker les données utilisateur. C'est un concept abstrait en langage informatique qui peut stocker des résultats de calcul ou représenter des valeurs.

La variable est le processus de localisation de la valeur via l'identifiant de la variable. Démonstration de simulation mémoire de variables :

2. Définition : déclaration et initialisation

Pour définir une variable, utilisez le mot clé var, et vous devez spécifier son type, qui peut être initialisé en même temps. . Si aucune valeur d'initialisation n'est spécifiée, utilisez le type. La valeur par défaut, la syntaxe est la suivante :

// 声明变量，未初始化（默认值初始化）
var name string
// 声明变量，特定值初始化
var user string = "Hank"

Les variables en langage Go doivent être déclarées avant de pouvoir être utilisées, et les variables non définies ne peuvent pas être utilisées directement.

3. Tapez la valeur par défaut (valeur zéro)

La valeur par défaut du type du langage Go est la suivante : La valeur par défaut des variables entières et à virgule flottante est 0. La valeur par défaut d'une variable chaîne est la chaîne vide. Les variables booléennes sont par défaut bool. La valeur par défaut pour les tranches, les fonctions et les variables de pointeur est nulle.

4. Typage fort

Le langage Go est un langage fortement typé, les variables doivent avoir des types et les variables ne peuvent stocker que des types spécifiques de données. [Recommandations associées : Tutoriel vidéo Go]

5. Dérivation de type

Lors de la définition d'une variable, si une valeur initiale est spécifiée, la définition du type peut être omise et le langage Go peut en déduire le type. les données par elles-mêmes. La syntaxe est :

// 声明变量，特定值初始化，类型推导出user为字符串string型
var user = "Hank"

6. Déclaration courte (définition)

Afin de simplifier la définition des variables, utilisez l'opérateur := avec dérivation de type pour compléter rapidement la définition des variables. :

user := "hank"

7. Définition du lot

Utilisez var ou := pour définir plusieurs variables à la fois. La syntaxe est :

varvar

var (
  v1 = 42
  v2 = "hank"
  )
也可以
var v1, v2 = 42, "hank"

:=

v1, v2 := 42, "hank"

:=

var (
  v1 int
  v2 int
)
// 批量赋值
v1, v2 = 42, 1024

Il est recommandé d'utiliser la syntaxe du bloc de déclaration var() car la maintenance du code est facile. 8. Affectation par lots

Attribuez des valeurs à plusieurs variables à la fois. (Semblable à une définition courte. v1, v2, v3 := 42, "hank", false) Une fois les variables définies, attribuez-leur des valeurs par lots. Il n'y a pas de fonction de définition ! La syntaxe est :

func main() {
  var (
    v1 int
    v2 int
  )
  // 调用函数，接收其返回值
  v1, v2 = getData()
}
// 返回两个值的函数
func getData() (int, int) {
  // 返回了两个值（假设42为最小值，1024为最大值）
  return 42, 1024
}

Cette syntaxe est généralement utilisée avec les retours par lots de fonctions pour recevoir plusieurs valeurs de retour en même temps. La syntaxe est :

var (
  v1 = 42
  v2 = 1024
)
// 交换
v1, v2 = v2, v1

Il est très pratique d'échanger les valeurs​. ​de deux variables :

func main() {
  var (
    v int
  )
  // 调用函数，仅仅需要第二个返回值，第一，三使用匿名变量占位
  _, v, _ = getData()
}
// 返回两个值的函数
func getData() (int, int, int) {
  // 返回3个值
  return 42, 1024, 2012
}

Après exécution, v1==1024, v2==429, variables anonymes

Les variables avec identifiant _ (trait de soulignement) sont des variables anonymes réservées par le système Après. affectation, ils seront immédiatement Release et l'appelleront une variable anonyme. Sa fonction est un espace réservé à une variable et une structure est affectée à ses variables. Généralement utilisé lors de l'affectation par lots. Par exemple, si une fonction renvoie plusieurs valeurs et que nous n'en avons besoin que de certaines, utilisez _ pour occuper l'espace si cela n'est pas nécessaire. Démonstration :

// 全局（函数外）定义3个变量
var (
  v1 = 1
  v2 = 2
  v3 = 3
)
func main() {

  // main{}函数块，定义2个变量
  var (
    v2 = 22
    v3 = 33
  )
  fmt.Println(v1, v2, v3)
  // 结果 1 22 33

  {
    // main()函数内部{}块，定义1个变量
    var (
      v3 = 333
    )
    fmt.Println(v1, v2, v3)
    // 结果 1 22 333
  }
}

10 Portée de la variable

Variables dans le. Le langage Go est un domaine de fonctions de bloc. Les blocs font référence à des segments de code définis à l'aide de {}, y compris les fonctions, les instructions if/switch/for ou les {} indépendants sont tous des blocs. Les variables définies dans un bloc ne sont disponibles que dans ce bloc. La définition fait référence aux variables définies par var ou :=. La portée du langage Go est en cascade, ce qui signifie que le bloc interne peut accéder directement aux variables du bloc externe, à condition que le bloc interne ne définisse pas de variable externe du même nom. Démonstration ci-dessous :

for i := 0; i < 10; i++ {
  fmt.Println(i)
}
fmt.Println(i)
// 会提示变量i未定义, undefined: i

🎜

上面代码中： 在main()中，v2，v3被重新定义，则在main()中，v1是外部，而v2, v3是main函数局部的。 在main()内部的{}中，v3被重新定义，则在main()内部的{}中，v1是外部，而v2是main()定义的, v3是main()内部{}定义的的。

变量可以沿内部作用域向外部作用域查找变量的过程。

带有{}的语句，其中的变量也仅仅在内部有效，例如for，if，switch等，演示：

for i := 0; i < 10; i++ {
  fmt.Println(i)
}
fmt.Println(i)
// 会提示变量i未定义, undefined: i

注意i，是通过短声明在for内部定义的变量，仅仅在for内部有意义。

互不嵌套的{}见作用域不可见，不可互相访问。

func main() {
  {
    v := 42
  }
  {
    fmt.Println(v)
    // 会提示变量v未定义, undefined: v
  }
}

更多编程相关知识，请访问：编程教学！！

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!