Comment utiliser les variables et constantes en Go

Variables sont un concept de programmation important à maîtriser. Ce sont des symboles qui représentent une valeur que vous utilisez dans un programme.

Ce tutoriel couvrira quelques bases des variables et les meilleures pratiques pour les utiliser dans les programmes Go que vous créez.

Comprendre les Variables

En termes techniques, une variable consiste à assigner un emplacement de stockage à une valeur liée à un nom symbolique ou identifiant. Nous utilisons le nom de la variable pour référencer cette valeur stockée dans un programme informatique.

Nous pouvons considérer une variable comme une étiquette portant un nom, que vous attachez à une valeur.

Disons que nous avons un entier, 1032049348, et nous voulons le stocker dans une variable plutôt que de retaper constamment le long nombre encore et encore. Pour ce faire, nous pouvons utiliser un nom facile à retenir, comme la variable i. Pour stocker une valeur dans une variable, nous utilisons la syntaxe suivante:

i := 1032049348

Nous pouvons considérer cette variable comme une étiquette qui est liée à la valeur.

L’étiquette porte le nom de la variable i et est liée à la valeur entière 1032049348.

La phrase i := 1032049348 est une déclaration et une instruction d’assignation qui se compose de plusieurs parties:

• le nom de la variable (i)
• l’assignation de déclaration de variable courte (:=)
• la valeur qui est associée au nom de variable (1032049348)
• le type de données inféré par Go (int)

Nous verrons plus tard comment définir explicitement le type dans la section suivante.

Ensemble, ces éléments constituent l’instruction qui définit la variable i égale à la valeur de l’entier 1032049348.

Dès que nous définissons une variable égale à une valeur, nous initialisons ou créons cette variable. Une fois que nous avons fait cela, nous sommes prêts à utiliser la variable à la place de la valeur.

Une fois que nous avons défini i égal à la valeur de 1032049348, nous pouvons utiliser i à la place de l’entier, alors imprimons-le :

package main

import "fmt"

func main() {
	i := 1032049348
	fmt.Println(i)
}

Output
1032049348

Nous pouvons également effectuer rapidement et facilement des calculs en utilisant des variables. Avec i := 1032049348, nous pouvons soustraire la valeur entière 813 avec la syntaxe suivante :

fmt.Println(i - 813)

Output
1032048535

Dans cet exemple, Go fait le calcul pour nous, soustrayant 813 de la variable i pour retourner la somme 1032048535.

En parlant de mathématiques, les variables peuvent être définies égales au résultat d’une équation mathématique. Vous pouvez également additionner deux nombres et stocker la valeur de la somme dans la variable x :

x := 76 + 145

Vous avez peut-être remarqué que cet exemple ressemble à l’algèbre. De la même manière que nous utilisons des lettres et d’autres symboles pour représenter des nombres et des quantités dans des formules et des équations, les variables sont des noms symboliques qui représentent la valeur d’un type de données. Pour une syntaxe Go correcte, vous devez vous assurer que votre variable est à gauche de toute équation.

Allons-y et imprimons x :

package main

import "fmt"

func main() {
	x := 76 + 145
	fmt.Println(x)
}

Output
221

Go a retourné la valeur 221 car la variable x a été définie égale à la somme de 76 et 145.

Les variables peuvent représenter n’importe quel type de données, pas seulement des entiers :

s := "Hello, World!"
f := 45.06
b := 5 > 9 // Une valeur booléenne retournera soit true, soit false
array := [4]string{"item_1", "item_2", "item_3", "item_4"}
slice := []string{"one", "two", "three"}
m := map[string]string{"letter": "g", "number": "seven", "symbol": "&"}

Si vous imprimez l’une de ces variables, Go retournera ce à quoi cette variable est équivalente. Travaillons avec l’instruction d’affectation pour le type de données slice chaîne :

package main

import "fmt"

func main() {
	slice := []string{"one", "two", "three"}
	fmt.Println(slice)
}

Output
[one two three]

Nous avons assigné la valeur de slice []string{"one", "two", "three"} à la variable slice, puis utilisé la fonction fmt.Println pour imprimer cette valeur en appelant slice.

Les variables fonctionnent en réservant une petite zone de mémoire dans votre ordinateur qui accepte des valeurs spécifiées qui sont ensuite associées à cet espace.

Déclaration de Variables

En Go, il existe plusieurs façons de déclarer une variable, et dans certains cas, plus d’une façon de déclarer exactement la même variable et la même valeur.

Nous pouvons déclarer une variable appelée i de type de données int sans initialisation. Cela signifie que nous allons déclarer un espace pour mettre une valeur, mais ne lui donnerons pas de valeur initiale :

var i int

Cela crée une variable déclarée comme i de type de données int.

Nous pouvons initialiser la valeur en utilisant l’opérateur égal (=), comme dans l’exemple suivant :

var i int = 1

En Go, les deux formes de déclaration sont appelées déclarations de variable longues.

Nous pouvons également utiliser déclaration de variable courte :

i := 1

Dans ce cas, nous avons une variable appelée i, et un type de données int. Lorsque nous n’indiquons pas un type de données, Go déduira le type de données.

Avec les trois façons de déclarer des variables, la communauté Go a adopté les idiomes suivants :

• N’utilisez que la forme longue, var i int, uniquement lorsque vous n’initialisez pas les variables.

• Utilisez la forme courte, i := 1, lors de la déclaration et de l’initialisation.

• Si vous ne souhaitez pas que Go infère votre type de données, mais que vous souhaitez quand même utiliser la déclaration de variable courte, vous pouvez envelopper votre valeur dans votre type de données souhaité, avec la syntaxe suivante :

i := int64(1)

Il n’est pas considéré comme idiomatique en Go d’utiliser la forme de déclaration de variable longue lors de l’initialisation de la valeur :

var i int = 1

Il est recommandé de suivre la pratique typique de la communauté Go pour déclarer les variables afin que d’autres puissent lire vos programmes sans difficulté.

Valeurs nulles

Tous les types intégrés ont une valeur nulle. Toute variable allouée est utilisable même si elle n’a jamais reçu de valeur. Nous pouvons voir les valeurs nulles pour les types suivants :

package main

import "fmt"

func main() {
	var a int
	var b string
	var c float64
	var d bool

	fmt.Printf("var a %T = %+v\n", a, a)
	fmt.Printf("var b %T = %q\n", b, b)
	fmt.Printf("var c %T = %+v\n", c, c)
	fmt.Printf("var d %T = %+v\n\n", d, d)
}

Output
var a int =  0
var b string = ""
var c float64 = 0
var d bool = false

Nous avons utilisé le verbe %T dans l’instruction fmt.Printf. Cela indique à la fonction d’imprimer le type de données pour la variable.

En Go, puisque toutes les valeurs ont une valeur nulle, nous ne pouvons pas avoir de valeurs indéfinies comme dans certains autres langages. Par exemple, un booléen dans certains langages pourrait être indéfini, vrai ou faux, ce qui permet à la variable d’avoir trois états. En Go, nous ne pouvons pas avoir plus de deux états pour une valeur booléenne.

Nomination des variables : Règles et style

La nomination des variables est assez flexible, mais il y a quelques règles à garder à l’esprit :

• Les noms de variables ne doivent être qu’un seul mot (sans espaces).
• Les noms de variables doivent être composés uniquement de lettres, de chiffres et de tirets bas (_).
• Les noms de variables ne peuvent pas commencer par un chiffre.

Suivant ces règles, examinons à la fois des noms de variables valides et invalides :

De plus, gardez à l’esprit que les noms de variables sont sensibles à la casse. Ces noms userName, USERNAME, UserName, et uSERnAME sont tous complètement différents. Il est recommandé d’éviter d’utiliser des noms de variables similaires dans un programme pour s’assurer que vous et vos collaborateurs, actuels et futurs, puissiez distinguer vos variables.

Bien que les variables soient sensibles à la casse, la casse de la première lettre d’une variable a une signification particulière en Go. Si une variable commence par une lettre majuscule, alors cette variable est accessible en dehors du package dans lequel elle a été déclarée (ou exportée). Si une variable commence par une lettre minuscule, alors elle n’est disponible que dans le package où elle est déclarée.

var Email string
var password string

Email commence par une lettre majuscule et peut être accédé par d’autres packages. password commence par une lettre minuscule et n’est accessible que dans le package où il est déclaré.

Il est courant en Go d’utiliser des noms de variables très concis (ou courts). Étant donné le choix entre userName et user pour une variable, il serait idiomatique de choisir user.

La portée joue également un rôle dans la concision du nom de la variable. La règle est que plus la portée dans laquelle la variable existe est petite, plus le nom de la variable est court :

names := []string{"Mary", "John", "Bob", "Anna"}
for i, n := range names {
	fmt.Printf("index: %d = %q\n", i, n)
}

Nous utilisons la variable names dans un contexte plus large, il est donc courant de lui donner un nom plus significatif pour faciliter la mémorisation de ce qu’elle représente dans le programme. Cependant, nous utilisons les variables i et n immédiatement dans la ligne de code suivante, puis ne les réutilisons plus… Pour cette raison, cela ne perturbera pas la compréhension de quelqu’un lisant le code sur l’endroit où les variables sont utilisées ou ce qu’elles signifient.

Ensuite, abordons quelques notes sur le style des variables. Le style consiste à utiliser MixedCaps ou mixedCaps plutôt que des underscores pour les noms composés de plusieurs mots.

La chose la plus importante concernant le style est d’être cohérent, et que l’équipe avec laquelle vous travaillez soit d’accord sur ce style.

Réassignation de Variables

Comme le mot « variable » l’indique, nous pouvons modifier facilement les variables en Go. Cela signifie que nous pouvons associer une valeur différente à une variable précédemment assignée par réassignation. Pouvoir réassigner est utile car tout au long d’un programme, nous pourrions avoir besoin d’intégrer des valeurs générées par l’utilisateur dans des variables déjà initialisées. Nous pourrions également avoir besoin de changer l’assignation à quelque chose de précédemment défini.

Savoir que nous pouvons facilement réassigner une variable peut être utile lorsque l’on travaille sur un grand programme écrit par quelqu’un d’autre, et il n’est pas clair quelles variables sont déjà définies.

Assignons la valeur 76 à une variable appelée i de type int, puis lui assignons une nouvelle valeur de 42 :

package main

import "fmt"

func main() {
	i := 76
	fmt.Println(i)

	i = 42
	fmt.Println(i)
}

Output
76
42

Cet exemple montre que nous pouvons d’abord assigner la variable i avec la valeur d’un entier, puis réassigner la variable i en lui assignant cette fois la valeur de 42.

Parce que Go est un langage typé, nous ne pouvons pas assigner un type à un autre. Par exemple, nous ne pouvons pas assigner la valeur "Sammy" à une variable de type int :

i := 72
i = "Sammy"

Essayer d’assigner des types différents les uns aux autres résultera en une erreur de compilation :

Output
cannot use "Sammy" (type string) as type int in assignment

Go ne nous permettra pas d’utiliser un nom de variable plus d’une fois :

var s string
var s string

Output
s redeclared in this block

Si nous essayons d’utiliser la déclaration de variable courte plus d’une fois pour le même nom de variable, nous recevrons également une erreur de compilation. Cela peut arriver par erreur, donc comprendre ce que signifie le message d’erreur est utile :

i := 5
i := 10

Output
no new variables on left side of :=

De manière similaire à la déclaration de variable, donner de la consideration à la nomination de vos variables améliorera la lisibilité de votre programme pour vous et les autres, lorsque vous y revenez à l’avenir.

Affectation multiple

Go permet également d’affecter plusieurs valeurs à plusieurs variables sur la même ligne. Chaque de ces valeurs peut être de type de données différent :

j, k, l := "shark", 2.05, 15
fmt.Println(j)
fmt.Println(k)
fmt.Println(l)

Output
shark
2.05
15

Dans cet exemple, la variable j a été affectée à la chaîne de caractères "requin", la variable k a été affectée au flottant 2.05, et la variable l a été affectée à l’entier 15.

Cette approche d’affectation de multiples variables à plusieurs valeurs sur une seule ligne peut réduire le nombre de lignes de code. Cependant, il est important de ne pas négliger la lisibilité au profit de plus petites quantités de code.

Variables globales et locales

Lors de l’utilisation de variables dans un programme, il est important de garder le domaine de variable à l’esprit. Le domaine d’une variable se réfère aux endroits spécifiques où elle est accessible dans le code d’un programme donné. Cela signifie que toutes les variables ne sont pas accessibles depuis toutes les parties d’un programme donné – certaines variables seront globales et d’autres seront locales.

Les variables globales existent en dehors des fonctions. Les variables locales existent à l’intérieur des fonctions.

Voyons les variables locales et globales en action :

package main

import "fmt"


var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
}

func main() {
	printLocal()
	fmt.Println(g)
}

Output
local
global

Ici, nous utilisons `var g = "global"` pour créer une variable globale en dehors de la fonction. Ensuite, nous définissons la fonction `printLocal()`. À l’intérieur de la fonction, une variable locale appelée `l` est assignée puis imprimée. Le programme se termine en appelant `printLocal()` et en imprimant ensuite la variable globale `g`.

Parce que `g` est une variable globale, nous pouvons nous y référer dans `printLocal()`. Modifions le programme précédent pour le faire :

package main

import "fmt"


var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
	fmt.Println(g)
}

func main() {
	printLocal()
	fmt.Println(g)
}

Output
local
global
global

Nous commençons par déclarer une variable globale `g`, `var g = "global"`. Dans la fonction `main`, nous appelons la fonction `printLocal`, qui déclare une variable locale `l` et l’imprime, `fmt.Println(l)`. Ensuite, `printLocal` imprime la variable globale `g`, `fmt.Println(g)`. Bien que `g` n’ait pas été défini dans `printLocal`, il pouvait toujours être accédé car il a été déclaré dans une portée globale. Enfin, la fonction `main` imprime également `g`.

Essayons maintenant d’appeler la variable locale en dehors de la fonction :

package main

import "fmt"

var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
}

func main() {
	fmt.Println(l)
}

Output
undefined: l

Nous ne pouvons pas utiliser une variable locale en dehors de la fonction dans laquelle elle est assignée. Si vous essayez de le faire, vous recevrez une erreur `undefined` lors de la compilation.

Examinons un autre exemple où nous utilisons le même nom de variable pour une variable globale et une variable locale :

package main

import "fmt"

var num1 = 5

func printNumbers() {
	num1 := 10
	num2 := 7  

	fmt.Println(num1)
	fmt.Println(num2)
}

func main() {
	printNumbers()
	fmt.Println(num1)
}

Output
10
7
5

Dans ce programme, nous avons déclaré la variable num1 à deux reprises. Tout d’abord, nous avons déclaré num1 à la portée globale, var num1 = 5, puis à nouveau dans la portée locale de la fonction printNumbers, num1 := 10. Lorsque nous affichons num1 depuis le programme main, nous voyons la valeur 5 s’afficher. En effet, main ne voit que la déclaration de la variable globale. Cependant, lorsque nous affichons num1 depuis la fonction printNumbers, elle voit la déclaration locale et affichera la valeur 10. Bien que printNumbers crée une nouvelle variable appelée num1 et lui attribue la valeur 10, cela n’affecte pas l’instance globale de num1 avec la valeur 5.

Lorsque vous travaillez avec des variables, vous devez également prendre en compte les parties de votre programme qui auront besoin d’accéder à chaque variable ; adopter une variable globale ou locale en conséquence. À travers les programmes Go, vous constaterez que les variables locales sont généralement plus courantes.

Constantes

Les constantes sont similaires aux variables, sauf qu’elles ne peuvent pas être modifiées une fois qu’elles ont été déclarées. Les constantes sont utiles pour définir une valeur qui sera utilisée plusieurs fois dans votre programme, mais qui ne devrait pas pouvoir changer.

Par exemple, si nous voulions déclarer le taux de taxe pour un système de panier d’achat, nous pourrions utiliser une constante et ensuite calculer la taxe dans différentes zones de notre programme. À un moment donné dans le futur, si le taux de taxe change, nous n’avons qu’à modifier cette valeur en un seul endroit de notre programme. Si nous utilisions une variable, il est possible que nous puissions accidentellement changer la valeur quelque part dans notre programme, ce qui entraînerait un calcul inapproprié.

Pour déclarer une constante, nous pouvons utiliser la syntaxe suivante:

const shark = "Sammy"
fmt.Println(shark)

Output
Sammy

Si nous essayons de modifier une constante après qu’elle a été déclarée, nous obtiendrons une erreur de compilation:

Output
cannot assign to shark

Les constantes peuvent être non typées. Cela peut être utile lorsque l’on travaille avec des nombres tels que des données de type entier. Si la constante est non typée, elle est convertie explicitement, alors que les constantes typées ne le sont pas. Voyons comment nous pouvons utiliser des constantes:

package main

import "fmt"

const (
	year     = 365
	leapYear = int32(366)
)

func main() {
	hours := 24
	minutes := int32(60)
	fmt.Println(hours * year)    
	fmt.Println(minutes * year)   
	fmt.Println(minutes * leapYear)
}

Output
8760
21900
21960

Si vous déclarez une constante avec un type, elle sera de ce type exact. Ici, lorsque nous déclarons la constante annéeBissextile, nous la définissons comme type de données int32. Par conséquent, c’est une constante typée, ce qui signifie qu’elle ne peut fonctionner qu’avec des types de données int32. La constante année que nous déclarons sans type, elle est donc considérée comme non typée. En raison de cela, vous pouvez l’utiliser avec n’importe quel type de données entier.

Lorsque heures a été défini, il a inféré qu’il était de type int parce que nous ne lui avons pas explicitement donné un type, heures := 24. Lorsque nous avons déclaré minutes, nous l’avons explicitement déclaré comme un int32, minutes := int32(60).

Passons maintenant en revue chaque calcul et pourquoi cela fonctionne:

hours * year

Dans ce cas, hours est un int, et years est non typé. Lors de la compilation, il convertit explicitement years en un int, ce qui permet à l’opération de multiplication de réussir.

minutes * year

Dans ce cas, minutes est un int32, et year est non typé. Lors de la compilation, il convertit explicitement years en un int32, ce qui permet à l’opération de multiplication de réussir.

minutes * leapYear

Dans ce cas, minutes est un int32, et leapYear est une constante typée de int32. Il n’y a rien à faire pour le compilateur cette fois-ci puisque les deux variables sont déjà du même type.

Si nous essayons de multiplier deux types qui sont typés et non compatibles, le programme ne compilera pas:

fmt.Println(hours * leapYear)

Output
invalid operation: hours * leapYear (mismatched types int and int32)

Dans ce cas, hours a été déduit comme un int, et leapYear a été explicitement déclaré comme un int32. Comme Go est un langage typé, un int et un int32 ne sont pas compatibles pour les opérations mathématiques. Pour les multiplier, vous auriez besoin de convertir l’un en int32 ou en int.

Conclusion

Dans ce tutoriel, nous avons revu certains des cas d’utilisation courants de variables dans Go. Les variables sont un bloc fondamental de programmation, servant comme des symboles qui représentent la valeur d’un type de données que nous utilisons dans un programme.