Aller aux variables de langue

Les variables proviennent des mathématiques et sont des concepts abstraits en langage informatique qui peuvent stocker des résultats de calcul ou représenter des valeurs. Les variables sont accessibles par nom de variable.

Les noms des variables de langue Go sont constitués de lettres, de chiffres et de traits de soulignement, et la première lettre ne peut pas être un chiffre.

La forme générale de déclaration des variables consiste à utiliser le mot-clé var :

var identifier type

Déclaration de variable

La première façon consiste à spécifier le type de variable si aucune valeur n'est attribuée après. déclaration, la valeur par défaut sera utilisée.

var v_name v_type
v_name = value

La deuxième méthode consiste à déterminer le type de variable en fonction de la valeur.

var v_name = value

La troisième méthode, omettre var, note : = La variable sur le côté gauche n'aurait pas dû être déclarée, sinon cela provoquera une erreur de compilation. L'exemple de

v_name := value

// 例如
var a int = 10
var b = 10
c : = 10

est le suivant :

package main
var a = "w3cschoolphp中文网"
var b string = "w3cschool.cc"
var c bool

func main(){
    println(a, b, c)
}

Le résultat d'exécution de l'exemple ci-dessus est :

w3cschoolphp中文网 w3cschool.cc false

Déclaration multi-variables

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 //和python很像,不需要显示声明类型，自动推断

vname1, vname2, vname3 := v1, v2, v3 //出现在:=左侧的变量不应该是已经被声明过的，否则会导致编译错误


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

L'exemple est le suivant :

package main

var x, y int
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

Le résultat de l'exécution de l'exemple ci-dessus est :

0 0 0 false 1 2 123 hello 123 hello

Type de valeur et type de référence

Tous les types de base tels que int, float, bool et string sont des types valeur, et les variables de ces types peuvent être utilisées directement Pointe vers une valeur stockée en mémoire :

Lors de l'utilisation du signe égal = pour attribuer la valeur d'une variable à une autre variable, telle que : j = i, i est en fait stocké en mémoire La valeur est copiée :

Vous pouvez utiliser &i pour obtenir l'adresse mémoire de la variable i, par exemple : 0xf840000040 (l'adresse peut être différent à chaque fois). La valeur d'une variable de type valeur est stockée sur la pile.

Les adresses mémoire varient en fonction de la machine. Même le même programme aura des adresses mémoire différentes après avoir été exécuté sur différentes machines. Parce que chaque machine peut avoir une configuration de mémoire différente et que l'allocation d'emplacement peut également être différente.

Les données plus complexes nécessitent généralement l'utilisation de plusieurs mots, et ces données sont généralement stockées à l'aide de types de référence.

Une variable de type référence r1 stocke l'adresse mémoire (numéro) où se trouve la valeur de r1, ou l'emplacement du premier mot dans l'adresse mémoire.

Cette adresse mémoire est appelée un pointeur, et ce pointeur est en fait stocké dans un autre mot.

Plusieurs mots pointés par des pointeurs du même type de référence peuvent être dans des adresses mémoire consécutives (la disposition de la mémoire est continue), ce qui est également la forme de stockage la plus efficace sur le plan informatique, ces mots peuvent également être dispersés. , chaque mot indique l'adresse mémoire du mot suivant.

Lors de l'utilisation de l'instruction d'affectation r2 = r1, seule la référence (adresse) est copiée.

Si la valeur de r1 est modifiée, alors toutes les références à cette valeur pointeront vers le contenu modifié. Dans cet exemple, r2 sera également affecté.

Forme courte, utilisez := opérateur d'affectation

Nous savons que le type de la variable peut être omis lors de l'initialisation de la variable et le système le déduira automatiquement. Cela semble en fait un peu déroutant. écrivez le mot-clé var dans l'instruction de déclaration. C'est redondant, nous pouvons donc les abréger en a := 50 ou b := false.

Les types de a et b (int et bool) seront automatiquement déduits par le compilateur.

Il s'agit de la forme préférée d'utilisation de variables, mais elle ne peut être utilisée que dans le corps de la fonction et ne peut pas être utilisée pour la déclaration et l'affectation de variables globales. Utilisez l'opérateur := pour créer efficacement une nouvelle variable, appelée déclaration d'initialisation.

Notes

Si nous ne pouvons pas utiliser à nouveau une déclaration d'initialisation pour une variable du même nom dans le même bloc de code, par exemple : a := 20 n'est pas autorisé, et le compilateur le fera erreur, aucune nouvelle variable sur le côté gauche de := n'est demandée, mais a = 20 est OK car cela attribue une nouvelle valeur à la même variable.

Si vous utilisez la variable a avant de la définir, vous obtiendrez l'erreur de compilation non définie : a.

Si vous déclarez une variable locale mais ne l'utilisez pas dans le même bloc de code, vous obtiendrez également une erreur de compilation, comme la variable a dans l'exemple suivant :

func main() {
   var a string = "abc"
   fmt.Println("hello, world")
}

Essayez de compiler ceci Le code obtiendra l'erreur a déclaré et non utilisé.

De plus, attribuer simplement une valeur à a ne suffit pas, la valeur doit être utilisée, donc utiliser

fmt.Println("hello, world", a)

supprimera l'erreur.

Mais les variables globales peuvent être déclarées mais pas utilisées.

Plusieurs variables du même type peuvent être déclarées sur la même ligne, telles que :

var a, b, c int

Plusieurs variables peuvent être affectées sur la même ligne, telles que :

a, b, c = 5, 7, "abc"

La ligne ci-dessus On suppose que les variables a, b et c ont été déclarées, sinon elle doit être utilisée comme ceci :

a, b, c := 5, 7, "abc"

Les valeurs de droite sont affectées aux variables de gauche dans le même ordre, donc la valeur de a est 5 et la valeur de b est 7, et la valeur de c est "abc".

C'est ce qu'on appelle l'affectation parallèle ou simultanée.

Si vous souhaitez échanger les valeurs de deux variables, vous pouvez simplement utiliser a, b = b, a.

L'identifiant d'espace _ est également utilisé pour supprimer des valeurs, par exemple la valeur 5 est supprimée dans : _, b = 5, 7.

_ est en fait une variable en écriture seule, vous ne pouvez pas obtenir sa valeur. Ceci est dû au fait que dans Go, vous devez utiliser toutes les variables déclarées, mais parfois vous n'avez pas besoin d'utiliser toutes les valeurs de retour d'une fonction.

L'affectation parallèle est également utilisée lorsqu'une fonction renvoie plusieurs valeurs de retour. Par exemple, val et error err ici sont obtenus simultanément en appelant la fonction Func1 : val, err = Func1(var1).