Variables en Go

Une variable est un emplacement de stockage pour conserver une valeur, permettant à la valeur stockée de changer dynamiquement pendant l'exécution. Chaque fois qu'une variable est déclarée, un bloc de mémoire lui est alloué pour stocker la valeur du type correspondant. Consultez Manuel de référence - Variables pour plus de détails.

Déclaration

En Go, la déclaration de type est postfixée. La déclaration de variable utilise le mot-clé var. Le format est var nom_variable type_nom. Le nom de la variable doit respecter les règles de nommage des identifiants.

var intNum int
var str string
var char byte

Lors de la déclaration de plusieurs variables du même type, le type ne peut être écrit qu'une seule fois :

var numA, numB, numC int

Lors de la déclaration de plusieurs variables de types différents, vous pouvez utiliser () pour les envelopper. Il peut y avoir plusieurs ().

var (
  name    string
  age     int
  address string
)

var (
  school string
  class int
)

Si une variable est déclarée sans affectation de valeur, la valeur stockée dans la variable est la valeur zéro du type correspondant.

Affectation

L'affectation utilise l'opérateur =. Par exemple :

var name string
name = "jack"

Vous pouvez également affecter directement lors de la déclaration :

var name string = "jack"

Ou cela fonctionne aussi :

var name string
var age int
name, age = "jack", 1

La deuxième méthode nécessite de spécifier le type à chaque fois. Vous pouvez utiliser la syntaxe fournie par l'officiel : l'initialisation de variable courte, qui omet le mot-clé var et le type postfixé, laissant le compilateur déduire le type.

name := "jack" // Variable de type chaîne.

Bien qu'il ne soit pas nécessaire de spécifier le type, le type doit rester cohérent lors des affectations ultérieures. Le code suivant ne passera pas la compilation :

a := 1
a = "1"

Il convient également de noter que l'initialisation de variable courte ne peut pas utiliser nil, car nil n'appartient à aucun type et le compilateur ne peut pas déduire son type.

name := nil // Ne passe pas la compilation

La déclaration de variable courte peut initialiser en lot :

name, age := "jack", 1

La déclaration de variable courte ne peut pas être utilisée sur une variable déjà existante. Par exemple :

// Exemple incorrect
var a int
a := 1

// Exemple incorrect
a := 1
a := 2

Mais il y a une exception : lorsqu'on affecte une ancienne variable tout en déclarant une nouvelle variable. Par exemple :

a := 1
a, b := 2, 2

Un tel code peut passer la compilation. La variable a est réaffectée, tandis que b est nouvellement déclarée.

En langage Go, il y a une règle : toutes les variables dans une fonction doivent être utilisées. Par exemple, le code suivant déclare simplement une variable sans l'utiliser :

func main() {
  a := 1
}

Lors de la compilation, une erreur sera signalée, indiquant que la variable est déclarée mais non utilisée :

a declared and not used

Cette règle s'applique uniquement aux variables dans les fonctions. Il n'y a pas cette restriction pour les variables de niveau paquet en dehors des fonctions. Le code suivant peut passer la compilation :

var a = 1

func main() {

}

Anonyme

Utilisez un underscore pour indiquer qu'une variable n'est pas nécessaire :

Open(name string) (*File, error)

Par exemple, la fonction os.Open a deux valeurs de retour. Nous voulons seulement la première, pas la seconde. Nous pouvons écrire comme suit :

file, _ := os.Open("readme.txt")

Une variable non utilisée ne passera pas la compilation. Lorsque vous n'avez pas besoin d'une variable, vous pouvez utiliser l'underscore _ à la place.

Échange

En Go, si vous souhaitez échanger les valeurs de deux variables, il n'est pas nécessaire d'utiliser des pointeurs. Vous pouvez utiliser directement l'opérateur d'affectation pour échanger. La syntaxe est très intuitive. Voici un exemple :

num1, num2 := 25, 36
num1, num2 = num2, num1

Trois variables fonctionnent de la même manière :

num1, num2, num3 := 25, 36, 49
num1, num2, num3  = num3, num2, num1

Réfléchissez au code suivant. Il s'agit d'un petit morceau de code pour calculer la suite de Fibonacci. Quelles sont les valeurs respectives des trois variables après calcul ?

a, b, c := 0, 1, 1
a, b, c = b, c, a+b

La réponse est :

1 1 1

Vous pourriez vous demander pourquoi ce n'est pas :

1 1 2

Bien que a ait été affecté la valeur de b, pourquoi le résultat de a+b est-il toujours 1 ? Lors de l'exécution d'opérations d'affectation sur plusieurs variables en Go, l'ordre est de calculer d'abord les valeurs, puis de les affecter, et non de gauche à droite.

a, b, c = b, c, a+b

Vous pourriez penser que cela sera développé comme suit :

a = b
b = c
c = a + b

Mais en réalité, les valeurs des trois variables a, b, c sont d'abord calculées, puis affectées. C'est équivalent au code suivant :

a, b, c = 1, 1, 0+1

Lorsqu'il s'agit d'appels de fonctions, cet effet est encore plus évident. Nous avons une fonction sum qui peut calculer la valeur de retour de deux nombres :

func sum(a, b int) int {
  return a + b
}

Utiliser une fonction pour additionner deux nombres :

a, b, c := 0, 1, 1
a, b, c = b, c, sum(a, b)

Le résultat ne change pas. Lors du calcul de la valeur de retour de la fonction sum, ses paramètres d'entrée sont toujours 0 et 1 :

1 1 1

Donc le code devrait être écrit séparément comme suit :

a, b = b, c
c = a + b

Comparaison

La comparaison entre variables a une condition préalable : leurs types doivent être identiques. Le langage Go n'effectue pas de conversion de type implicite. Le code suivant ne passera pas la compilation :

func main() {
  var a uint64
  var b int64
  fmt.Println(a == b)
}

Le compilateur vous indiquera que les types des deux ne sont pas identiques :

invalid operation: a == b (mismatched types uint64 and int64)

Il est donc nécessaire d'utiliser une conversion de type explicite :

func main() {
  var a uint64
  var b int64
  fmt.Println(int64(a) == b)
}

Avant les génériques, les fonctions intégrées min et max fournies par Go ne prenaient en charge que les nombres flottants. Dans la version 1.21, Go a enfin réécrit ces deux fonctions intégrées avec des génériques. Maintenant, vous pouvez utiliser la fonction min pour comparer la valeur minimale :

minVal := min(1, 2, -1, 1.2)

Utilisez la fonction max pour comparer la valeur maximale :

maxVal := max(100, 22, -1, 1.12)

Leurs paramètres prennent en charge tous les types comparables. Les types comparables en Go sont :

Booléen
Nombre
Chaîne
Pointeur
Canal (prend uniquement en charge la vérification d'égalité)
Tableau dont les éléments sont de types comparables (les tranches ne sont pas comparables) (prend uniquement en charge la vérification d'égalité) (prend uniquement en charge la comparaison entre tableaux de même longueur, car la longueur du tableau fait également partie du type, et les types différents ne sont pas comparables)
Structure dont les champs sont de types comparables (prend uniquement en charge la vérification d'égalité)

En outre, vous pouvez également importer la bibliothèque standard cmp pour effectuer des comparaisons, mais elle prend uniquement en charge les paramètres de types ordonnés. Les types ordonnés intégrés en Go sont uniquement les nombres et les chaînes.

import "cmp"

func main() {
  cmp.Compare(1, 2)
  cmp.Less(1, 2)
}

Blocs de code

À l'intérieur d'une fonction, vous pouvez établir un bloc de code avec des accolades. Les domaines de variables entre les blocs de code sont indépendants les uns des autres. Par exemple, le code suivant :

func main() {
  a := 1

  {
    a := 2
    fmt.Println(a)
  }

  {
    a := 3
    fmt.Println(a)
  }
  fmt.Println(a)
}

Sa sortie est :

2
3
1

Les variables entre les blocs sont indépendantes, ne s'interfèrent pas et ne sont pas accessibles, mais sont affectées par le bloc parent.

func main() {
  a := 1

  {
    a := 2
    fmt.Println(a)
  }

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

Sa sortie est :

2
1
1

Variables en Go ​

Déclaration ​

Affectation ​

Anonyme ​

Échange ​

Comparaison ​

Blocs de code ​