Variables du langage Go
Les variables proviennent des mathématiques ; dans les langages informatiques, ce sont des concepts abstraits qui peuvent stocker des résultats de calcul ou représenter des valeurs.
Les variables sont accessibles via leurs noms de variables.
Les noms de variables Go sont composés de lettres, de chiffres et de traits de soulignement, et le premier caractère ne peut pas être un chiffre.
La forme générale de déclaration d'une variable consiste à utiliser le mot-clé var :
var identifier type
Plusieurs variables peuvent être déclarées en même temps :
var identifier1, identifier2 type
Exemple
import "fmt"
func main() {
var a string = "Example"
fmt.Println(a)
var b, c int = 1, 2
fmt.Println(b, c)
}
La sortie de l'exemple ci-dessus est :
Example 1 2
Déclaration de variable
Tout d'abord, spécifiez le type de la variable. Si elle n'est pas initialisée, la variable prend par défaut sa valeur zéro.。
var v_name v_type v_name = value
La valeur zéro est la valeur attribuée par défaut par le système lorsque la variable n'a pas été initialisée.
Exemple
import "fmt"
func main() {
// Déclarer une variable et l'initialiser
var a = "EXAMPLE"
fmt.Println(a)
// Sans initialisation, elle vaut la valeur zéro
var b int
fmt.Println(b)
// La valeur zéro de bool est false
var c bool
fmt.Println(c)
}
Le résultat d'exécution de l'exemple ci-dessus est :
EXAMPLE 0 false
Les types numériques (y compris complex64/128) sont0
-
Le type booléen estfalse
-
La chaîne est""(chaîne vide)
Les types suivants sont :nil：
var a *int var a []int var a map[string] int var a chan int var a func(string) int var a error // error 是接口
Exemple
import "fmt"
func main() {
var i int
var f float64
var b bool
var s string
fmt.Printf("%v %v %v %q\n", i, f, b, s)
}
La sortie est :
0 0 false ""
Deuxièmement, le type de la variable est déterminé par la valeur elle-même.
var v_name = value
Exemple
import "fmt"
func main() {
var d = true
fmt.Println(d)
}
La sortie est :
true
Troisièmement, si une variable a déjà été déclarée avec var, alors l'utiliser à nouveau:=pour déclarer la variable produira une erreur de compilation. Format :
v_name := value
Par exemple :
var intVal int intVal :=1 // 这时候会产生编译错误，因为 intVal 已经声明，不需要重新声明
Utilisez simplement l'instruction suivante :
intVal := 1 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句
intVal := 1Égal à :
var intVal int intVal =1
Vous pouvez abréger var f string = "Example" en f := "Example" :
Exemple
import "fmt"
func main() {
f := "Example" // var f string = "Example"
fmt.Println(f)
}
La sortie est :
Example
Déclaration de plusieurs 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
)
Exemple
import "fmt"
var x, y int
var ( // Cette syntaxe de mot-clé factorisée est généralement utilisée pour déclarer des variables globales
a int
b bool
)
var c, d int = 1, 2
var e, f = 123, "hello"
// Cette forme sans la syntaxe de déclaration ne peut apparaître qu'à l'intérieur du corps d'une fonction
//g, h := 123, "hello"
func main(){
g, h := 123, "hello"
fmt.Println(x, y, a, b, c, d, e, f, g, h)
}
Le résultat d'exécution de l'exemple ci-dessus est :
0 0 0 false 1 2 123 hello 123 hello
Types valeur et types référence
Tous les types de base tels que int, float, bool et string sont des types valeur. Les variables de ces types pointent directement vers des valeurs stockées en mémoire :
Lors de l'utilisation du signe égal=Lorsque vous affectez la valeur d'une variable à une autre variable, comme suit :j = ien fait, cela copie la valeur de i en mémoire :
Vous pouvez obtenir l'adresse mémoire de la variable i via &i, par exemple : 0xf840000040 (l'adresse peut être différente à chaque fois).
Les variables de type valeur sont généralement stockées sur la pile, en particulier lorsqu'il s'agit de variables locales. Lorsque la valeur d'une variable de type valeur doit être utilisée en dehors de la portée de la fonction, Go l'alloue dans le tas.
Les adresses mémoire peuvent différer selon la machine, et même un même programme peut avoir des adresses mémoire différentes après avoir été exécuté sur différentes machines. Cela tient au fait que chaque machine peut avoir une disposition mémoire différente, et que l'allocation des emplacements peut également différer.
Les données plus complexes nécessitent généralement plusieurs mots, et ces données sont généralement stockées à l'aide de types référence.
Une variable de type référence r1 stocke l'adresse mémoire (un nombre) où se trouve la valeur de r1, ou la position du premier mot à cette adresse mémoire.
Cette adresse mémoire est appelée un pointeur, et ce pointeur est en fait stocké dans une autre valeur.
Les multiples mots pointés par un pointeur du même type référence peuvent se trouver à des adresses mémoire consécutives (disposition mémoire contiguë), ce qui constitue également la forme de stockage la plus efficace en termes de calcul ; alternativement, ces mots peuvent être dispersés en mémoire, chaque mot indiquant l'adresse mémoire du mot suivant.
Lorsque l'instruction d'affectation r2 = r1 est utilisée, seule la référence (l'adresse) est copiée.
Si la valeur de r1 est modifiée, toutes les références à cette valeur pointeront vers le contenu modifié. Dans cet exemple, r2 sera également affectée.
Forme abrégée, utilisant l'opérateur d'affectation :=
Nous savons que le type de variable peut être omis lors de l'initialisation d'une variable et automatiquement déduit par le système. Inclure le mot-clé var dans l'instruction de déclaration est quelque peu redondant, nous pouvons donc l'abréger en a := 50 ou b := false.
Les types de a et b (int et bool) seront automatiquement déduits par le compilateur.
C'est la forme privilégiée pour utiliser des variables, mais elle ne peut être utilisée qu'à l'intérieur du corps d'une fonction, et ne peut pas servir à déclarer et affecter des variables globales. Utiliser l'opérateur := permet de créer efficacement une nouvelle variable, ce que l'on appelle une déclaration d'initialisation.
Notes
Dans le même bloc de code, nous ne pouvons pas utiliser à nouveau une déclaration d'initialisation pour une variable portant le même nom. Par exemple, a := 20 n'est pas autorisé, et le compilateur signalera une erreur : no new variables on left side of :=, mais a = 20 est autorisé, car cela affecte une nouvelle valeur à la même variable.
Si vous utilisez la variable a avant de la définir, vous obtiendrez une erreur de compilation : undefined: 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 :
Exemple
import "fmt"
func main() {
var a string = "abc"
fmt.Println("hello, world")
}
Tenter de compiler ce code entraînera une erreur.a declared but not used。
De plus, le simple fait d'affecter une valeur à a ne suffit pas ; cette valeur doit être utilisée, alors utilisez
fmt.Println("hello, world", a)Cela supprimera l'erreur.
Mais les variables globales peuvent être déclarées sans être utilisées.
var a, b, c int
Plusieurs variables peuvent être affectées sur la même ligne, comme :
var a, b int var c string a, b, c = 5, 7, "abc"
La ligne ci-dessus suppose que les variables a, b et c ont déjà é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, la valeur de b est 7, et la valeur de c est "abc".
C'est ce qu'on appelle une affectation parallèle ou simultanée.
Si vous souhaitez échanger les valeurs de deux variables, vous pouvez simplement utilisera, b = b, ales types des deux variables doivent être identiques.
L'identificateur vide _ est également utilisé pour écarter des valeurs, comme la valeur 5 dans : _, b = 5, 7 est écartée.
_ est en fait une variable en écriture seule ; vous ne pouvez pas obtenir sa valeur. Cela est fait parce qu'en Go, vous devez utiliser toutes les variables déclarées, mais parfois vous n'avez pas besoin d'utiliser toutes les valeurs de retour obtenues d'une fonction.
L'affectation parallèle est également utilisée lorsqu'une fonction renvoie plusieurs valeurs de retour. Par exemple, ici val et l'erreur err sont obtenus simultanément en appelant la fonction Func1 : val, err = Func1(var1).
autres extensions