Aller - Variables

Une variable n'est rien d'autre qu'un nom donné à une zone de stockage que les programmes peuvent manipuler. Chaque variable dans Go a un type spécifique, qui détermine la taille et la disposition de la mémoire de la variable, la plage de valeurs qui peuvent être stockées dans cette mémoire et l'ensemble des opérations qui peuvent être appliquées à la variable.

Le nom d'une variable peut être composé de lettres, de chiffres et du caractère de soulignement. Il doit commencer par une lettre ou un trait de soulignement. Les lettres majuscules et minuscules sont distinctes car Go est sensible à la casse. Sur la base des types de base expliqués dans le chapitre précédent, il y aura les types de variables de base suivants -

Sr. Non	Type et description
1	byte Généralement un seul octet (un octet). C'est un type d'octet.
2	int La taille entière la plus naturelle de la machine.
3	float32 Valeur à virgule flottante simple précision.

Le langage de programmation Go permet également de définir divers autres types de variables telles que l'énumération, le pointeur, le tableau, la structure et l'union, dont nous parlerons dans les chapitres suivants. Dans ce chapitre, nous nous concentrerons uniquement sur les types de variables de base.

Définition de variable dans Go

Une définition de variable indique au compilateur où et combien de stockage créer pour la variable. Une définition de variable spécifie un type de données et contient une liste d'une ou plusieurs variables de ce type comme suit -

var variable_list optional_data_type;

Ici, optional_data_type est un type de données Go valide incluant byte, int, float32, complex64, boolean ou tout objet défini par l'utilisateur, etc., et variable_listpeut consister en un ou plusieurs noms d'identificateurs séparés par des virgules. Certaines déclarations valides sont affichées ici -

var  i, j, k int;
var  c, ch byte;
var  f, salary float32;
d =  42;

La déclaration “var i, j, k;”déclare et définit les variables i, j et k; qui demande au compilateur de créer des variables nommées i, j et k de type int.

Les variables peuvent être initialisées (affectées d'une valeur initiale) dans leur déclaration. Le type de variable est automatiquement jugé par le compilateur en fonction de la valeur qui lui est transmise. L'initialiseur se compose d'un signe égal suivi d'une expression constante comme suit -

variable_name = value;

Par exemple,

d = 3, f = 5;    // declaration of d and f. Here d and f are int

Pour une définition sans initialiseur: les variables avec une durée de stockage statique sont implicitement initialisées avec nil (tous les octets ont la valeur 0); la valeur initiale de toutes les autres variables est la valeur zéro de leur type de données.

Déclaration de type statique dans Go

Une déclaration de variable de type statique fournit l'assurance au compilateur qu'il y a une variable disponible avec le type et le nom donnés afin que le compilateur puisse poursuivre la compilation sans exiger le détail complet de la variable. Une déclaration de variable n'a sa signification qu'au moment de la compilation, le compilateur a besoin de la déclaration de variable réelle au moment de la liaison du programme.

Exemple

Essayez l'exemple suivant, où la variable a été déclarée avec un type et initialisée dans la fonction principale -

package main

import "fmt"

func main() {
   var x float64
   x = 20.0
   fmt.Println(x)
   fmt.Printf("x is of type %T\n", x)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

20
x is of type float64

Déclaration de type dynamique / Inférence de type dans Go

Une déclaration de variable de type dynamique nécessite que le compilateur interprète le type de la variable en fonction de la valeur qui lui est transmise. Le compilateur n'exige pas qu'une variable ait un type statique comme condition nécessaire.

Exemple

Essayez l'exemple suivant, où les variables ont été déclarées sans aucun type. Remarquez, en cas d'inférence de type, nous avons initialisé la variabley avec: = opérateur, alors que x est initialisé à l'aide de l'opérateur =.

package main

import "fmt"

func main() {
   var x float64 = 20.0

   y := 42 
   fmt.Println(x)
   fmt.Println(y)
   fmt.Printf("x is of type %T\n", x)
   fmt.Printf("y is of type %T\n", y)	
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

20
42
x is of type float64
y is of type int

Déclaration de variable mixte dans Go

Des variables de types différents peuvent être déclarées en une seule fois à l'aide de l'inférence de type.

Exemple

package main

import "fmt"

func main() {
   var a, b, c = 3, 4, "foo"  
	
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Printf("a is of type %T\n", a)
   fmt.Printf("b is of type %T\n", b)
   fmt.Printf("c is of type %T\n", c)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

3
4
foo
a is of type int
b is of type int
c is of type string

Les lvalues ​​et les rvalues ​​dans Go

Il existe deux types d'expressions dans Go -

• lvalue- Les expressions qui font référence à un emplacement mémoire sont appelées expression "lvalue". Une lvalue peut apparaître comme le côté gauche ou droit d'une affectation.

• rvalue- Le terme rvalue fait référence à une valeur de données qui est stockée à une certaine adresse en mémoire. Une rvalue est une expression qui ne peut pas avoir de valeur assignée, ce qui signifie qu'une rvalue peut apparaître à droite mais pas à gauche d'une affectation.

Les variables sont des valeurs l et peuvent donc apparaître sur le côté gauche d'une affectation. Les littéraux numériques sont des valeurs r et ne peuvent donc pas être affectés et ne peuvent pas apparaître sur le côté gauche.

La déclaration suivante est valide -

x = 20.0

La déclaration suivante n'est pas valide. Cela générerait une erreur de compilation -

10 = 20