Introduction aux variables en Go

Introduction

Pourquoi les langages de programmation ont-ils besoin de variables ? C’est une question ancienne. De même que nous pouvons retenir que l’URL de LabEx est labex.io, les programmes informatiques doivent aussi mémoriser des données pour les utiliser.

Les variables servent à représenter une donnée. Dans cette section, vous découvrirez comment utiliser les variables en Go.

Points abordés :

• Déclaration de variables
• Initialisation de variables
• Utilisation de variables
• Durée de vie des variables
• Constantes

Qu’est-ce qu’une variable ?

Dans cette étape, vous découvrirez ce que représentent les variables et comment Go impose des règles concernant leurs noms et leurs types.

Qu’est-ce qu’une variable ? En termes simples, une variable est un conteneur qui sert à stocker et à conserver une donnée modifiable.

Dans les langages compilés comme Go, le type d’une variable est fixe.

Que signifie « type de variable fixe » ?

Cela signifie qu’une variable ne peut contenir qu’un seul type de donnée. Autrement dit, les éléments stockés dans le conteneur de la variable sont d’un type déterminé.

Si une variable sert à contenir des fruits, elle ne doit contenir que des fruits. Une fois que le conteneur a contenu des fruits, il ne peut pas servir à contenir des biscuits. Dans le code, cela signifie qu’une variable ne peut pas recevoir des données de deux types différents.

Mutabilité des variables

Comme son nom l’indique, la valeur d’une variable peut changer, à condition que la nouvelle valeur reste dans les limites autorisées par son type.

Le langage Go applique les règles suivantes aux variables :

• Le nom doit être composé de lettres, de chiffres et de caractères de soulignement.
• L’identifiant de la variable ne peut pas commencer par un chiffre.
• L’identifiant ne peut pas être un mot-clé réservé. Consultez les mots-clés réservés
• Les noms de variables sont sensibles à la casse, mais il est déconseillé d’utiliser des majuscules et des minuscules différentes pour distinguer deux variables portant le même nom.

Méthode de déclaration générale

Dans cette étape, vous apprendrez à déclarer une variable typée avec le mot-clé var.

En Go, le mot-clé utilisé pour déclarer une variable avec la méthode générale est var.

La forme de la déclaration est var identifier type, ce qui signifie :

var variableName variableType.

Quels sont les types de variables courants en Go ?

Les types de variables ne sont pas l’objectif principal de cette section. Seuls les trois types les plus courants sont donc présentés.

D’autres types seront expliqués dans les cours suivants.

Comment déclarer une variable ?

Déclarons maintenant une variable entière nommée a.

var a int

Pour retenir cette syntaxe, vous pouvez la lire mentalement ainsi :

Define a variable named `a`, which is of type int.

Contrairement à de nombreux langages de programmation traditionnels, le type de la variable est placé après son nom en Go.

Cette syntaxe rend le code plus facile à lire de gauche à droite et évite la logique de lecture en spirale du langage C. Pour plus de détails, consultez la documentation officielle.

Quel nom donner à une variable ?

Un bon nom de variable doit indiquer clairement la signification de la variable.

Lorsque vous nommez des variables, veillez à choisir des noms explicites et évitez les abréviations.

Nous allons présenter brièvement la méthode de base pour nommer les variables : la convention camelCase.

La convention camelCase utilise des lettres minuscules et majuscules pour représenter un nom de variable. Le premier mot commence par une minuscule et la première lettre de chaque mot suivant est une majuscule.

Par exemple : currentDate. Le premier mot, current, commence par une minuscule, tandis que le second mot, Date, commence par une majuscule.

Ainsi, il est facile de comprendre que cette variable représente la date actuelle.

Cette convention est généralement utilisée pour les variables importantes et fréquemment utilisées. Les variables temporaires peuvent avoir des noms plus courts, tant qu’elles ne créent pas de doublons.

Méthode de déclaration groupée

Dans cette étape, vous apprendrez à déclarer plusieurs variables en même temps.

Déclarons maintenant trois variables :

var a int // Declare an integer variable named a
var b int // Declare an integer variable named b
var c int // Declare an integer variable named c

Vous avez peut-être remarqué que les trois variables, a, b, c, sont toutes de type int.

Dans ce cas, nous pouvons utiliser une virgule pour relier les noms des variables et réduire la quantité de code.

var a, b, c int // Declare three variables a, b, c as integers

Mais que se passe-t-il si les trois variables ont des types différents ?

var a int    // Declare an integer variable named a
var b string // Declare a string variable named b
var c bool   // Declare a boolean variable named c

Nous avons déjà rencontré une situation similaire lors de l’importation de packages. Comme plusieurs packages portant des noms différents doivent parfois être importés ensemble, nous pouvons utiliser une syntaxe comparable :

var (
    a int
    b string
    c bool
)

Notez que cette forme de déclaration, similaire à celle utilisée pour importer des packages, sert généralement à définir des variables globales.

Initialisation par défaut

Dans cette étape, vous examinerez les valeurs par défaut que Go attribue aux variables.

En Go, toutes les variables reçoivent une valeur initiale lors de leur déclaration. Découvrons quelles sont ces valeurs initiales !

Créez un fichier nommé varExercise.go dans le répertoire ~/project.

touch ~/project/varExercise.go

Écrivez le code suivant dans ce fichier :

package main

import "fmt"

func main() {
    var a int
    var b string
    var c bool
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

Vous pouvez l’exécuter vous-même et vérifier si le résultat correspond au tableau ci-dessous.

go run varExercise.go

Les valeurs initiales sont résumées dans le tableau suivant :

Initialisation standard

Dans cette étape, vous initialiserez explicitement des variables, puis vous leur attribuerez de nouvelles valeurs.

Puisque Go peut déterminer le type d’une variable à partir de sa valeur initiale, pouvons-nous modifier la valeur par défaut ou la valeur d’une variable déjà déclarée ?

var a int = 1
var b string = "labex"
var c bool = true

a = 233
b = "labex"
c = false

Comme indiqué ci-dessus, il suffit d’ajouter = après la déclaration de la variable, puis de fournir une valeur initiale compatible avec le type de la variable. Pour modifier sa valeur, utilisez le nom de la variable suivi de =, puis fournissez une autre valeur du même type.

Modifiez le fichier varExercise.go :

package main

import "fmt"

func main() {
    // Declare and initialize
    var a int = 1
    var b string = "labex"
    var c bool = true

    // Print the variables
    fmt.Println("Before modification:")
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)

    // Modify the variables
    a = 233
    b = "labex"
    c = false

    // Print the modified variables
    fmt.Println("After modification:")
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

Après l’exécution du code, la sortie est la suivante :

$ go run varExercise.go
Before modification:
1
labex
true
After modification:
233
labex
false

Vous pouvez exécuter le code vous-même et modifier les valeurs initiales.

Nous avons indiqué que la valeur initiale attribuée à une variable doit avoir le même type que celui spécifié dans sa déclaration. Que se passe-t-il si les types sont différents ?

Par exemple, attribuons "labex" comme valeur initiale à la variable a :

package main

import "fmt"

func main() {
    var a int = "labex"
    fmt.Println(a)
}

Exécutez le code :

$ go run varExercise.go
## command-line-arguments
./varExercise.go:6:12: cannot use "labex" (type untyped string) as type int in assignment

Comme le montre le message d’erreur, nous ne pouvons pas attribuer une valeur de type chaîne telle que "labex" à une variable de type int. Go est un langage compilé fortement typé : le code ne peut donc pas être compilé.

Déclaration du type par inférence

Dans cette étape, vous déclarerez des variables locales avec l’inférence de type et l’opérateur :=.

Puisque Go peut déterminer le type d’une variable à partir de sa valeur initiale, pouvons-nous simplifier la déclaration en supprimant la spécification explicite du type ?

package main

import "fmt"

func main() {
    // var a int = 1
    var a = 1 // Type is inferred
    fmt.Println(a)
}

Vous n’avez même plus besoin d’utiliser le mot-clé var pour définir une variable.

Cette manière de déclarer et d’initialiser une variable peut aussi être combinée avec la méthode de déclaration groupée :

a, b, c := 0, 0, 0
// Declare variables a, b, c as integers and assign 0 to each variable.

Vous pouvez également initialiser les variables avec des valeurs de types différents :

a, b, c := 0, "", true
// Declare variables a, b, c as integer, string, and boolean, respectively.

Chaque variable située à gauche de := doit avoir une valeur initiale correspondante à droite.

La déclaration courte est très pratique, mais attention : := n’est pas une opération d’affectation. C’est une syntaxe de déclaration propre à Go, utilisée pour déclarer et initialiser des variables locales à l’intérieur d’une fonction. Le type de la variable est automatiquement déduit à partir de l’expression.

Il arrive que nous écrivions le code suivant :

func main() {
    a := 1
    println(a)
    a := 2
    println(a)
}

Le compilateur vous indiquera qu’une erreur se trouve dans le code, car la variable a a été déclarée une seconde fois. En revanche, le code suivant est valide :

func main() {
    a := 1
    if true {
        a := 2
        println(a) // Output: 2
    }
    println(a) // Output: 1
}

Cette sortie s’explique par le fait que la variable a ayant la valeur 1 et la variable a ayant la valeur 2 ne se trouvent pas dans la même portée de variable, c’est-à-dire entre les mêmes accolades. Le compilateur les considère donc comme deux variables différentes.

Le compilateur ne signalera pas cette situation comme une erreur, mais la sortie sera inattendue.

En Go, la règle suivante s’applique :

Chaque instruction située en dehors d’une fonction doit commencer par un mot-clé (var, func, etc.).

Par conséquent, la déclaration courte peut uniquement servir à déclarer des variables locales ; elle ne peut pas servir à déclarer des variables globales.

Qu’est-ce donc qu’une variable globale et qu’une variable locale ?

Cela concerne le concept de durée de vie des variables, qui sera expliqué dans la section suivante.

Portée des variables

Dans cette étape, vous comparerez la portée des variables locales, des variables globales et des paramètres formels.

La portée d’une variable désigne la zone dans laquelle cette variable est utilisable dans un programme.

Vous avez peut-être remarqué que si vous déclarez une variable sans l’utiliser, le code ne se compile pas.

Autrement dit, lors de la compilation, Go vérifie que chaque variable a été utilisée, c’est-à-dire qu’elle a été utilisée dans sa portée.

Selon leur position de déclaration, nous pouvons répartir les variables en trois catégories :

• Les variables définies dans une fonction, appelées variables locales
• Les variables définies en dehors d’une fonction, appelées variables globales
• Les variables définies dans la déclaration d’une fonction, appelées paramètres formels

Variables locales

Dans cette section, la plupart des variables que nous définissons sont des variables locales :

package main

import "fmt"

func main() { // Function body
    var a int = 1 // Local variable
    fmt.Println(a)
}

Les variables locales sont définies dans le corps d’une fonction, comme a, définie dans la fonction main. La portée de la variable a est limitée à la fonction main.

De même, si la variable n’est pas utilisée dans la fonction main, le compilateur signale une erreur.

Variables globales

Il est également possible de définir une variable globale.

package main

import "fmt"

var a int = 1 // Global variable
func main() { // Function body
    fmt.Println(a)
}

Les variables globales sont définies en dehors du corps d’une fonction et leur portée couvre l’ensemble du programme. Même si elles ne sont appelées dans aucune fonction, le compilateur ne signale pas d’erreur.

Réfléchissez à la raison pour laquelle les variables globales ne produisent pas d’erreur même lorsqu’elles ne sont pas appelées.

Les détails concernant les paramètres formels seront expliqués dans les prochains cours consacrés aux fonctions.

Durée de vie des variables

Dans cette étape, vous découvrirez combien de temps les variables restent accessibles et pourquoi une variable ne peut pas être redéclarée dans une même portée.

Les oiseaux qui s’envolent cachent la distance. Les lapins qui complotent meurent, et les chiens finiront en ragoût. - Mémoires de l’historien

Lorsqu’une variable a terminé son rôle, elle doit être détruite afin de réduire l’utilisation de la mémoire.

• Variables globales : la durée de vie d’une variable globale correspond à toute la durée d’exécution du programme. Lorsque le programme s’arrête, la variable globale est supprimée de la mémoire.
• Variables locales : lorsqu’il n’est plus possible d’accéder à une variable, l’espace mémoire qu’elle occupait est récupéré.

Cette conception est l’une des clés des performances élevées et de l’utilisation efficace de l’espace mémoire de Go.

Pendant toute sa durée de vie, une variable ne peut pas être redéclarée.

Vous pouvez écrire le code suivant dans varExercise.go :

package main

import "fmt"

func main() {
    var a int = 1 // Local variable, lifetime is limited to the entire main function
    var a int = 2 // Redefinition
    fmt.Println(a)
}

Après l’exécution du code :

go run varExercise.go

Vous verrez le message d’erreur suivant :

./varExercise.go:7:9: a redeclared in this block
previous declaration at ./varExercise.go:6:9

Le compilateur nous indique que a a été définie une seconde fois.

Constantes

Dans cette étape, vous déclarerez des constantes et déterminerez quelles expressions peuvent représenter des valeurs constantes valides.

Beaucoup de choses dans la vie sont comme des constantes. Nous pouvons les percevoir, mais nous ne pouvons pas les modifier.

Si une valeur ne doit pas changer pendant toute la durée d’exécution du programme, nous devons la définir comme une constante.

Les constantes ressemblent beaucoup aux variables. Vous pouvez même les considérer comme des variables dont la valeur est immuable.

Pour déclarer une constante, il suffit de remplacer le mot-clé var par le mot-clé const.

const Pi = 3.14159 // Using type inference initialization

Créez un fichier nommé constExercise.go dans le répertoire ~/project.

touch ~/project/constExercise.go

Que se passe-t-il si nous essayons de modifier une constante ?

package main

import "fmt"

func main() {
    const Pi = 3.14159
    Pi = 2 // Error: cannot assign to Pi
    fmt.Println(Pi)
}

Exécutez le code.

$ go run constExercise.go
## command-line-arguments
./constExercise.go:7:8: cannot assign to Pi

Le compilateur nous indique que la valeur de Pi ne peut pas être réaffectée.

Lors de la déclaration d’une constante, nous devons fournir une valeur initiale.

La valeur initiale attribuée à une constante doit être déterminée au moment de la compilation.

En Go, la valeur renvoyée par une fonction définie par l’utilisateur n’est pas considérée comme déterminée à la compilation.

var a int = 1
// Value is fixed, declaration is valid.
const Pi = 3.14159
// The calculated value is also fixed, the declaration is valid.
const c = 1 / Pi
// Fixed return value from built-in function is valid.
const le = len("labex")
// The return value of the user-defined function is not fixed, the declaration is invalid.
const le = getLen("labby")
// `a` is a variable value that is not fixed, the declaration is invalid.
const k = a

La validité d’une déclaration de constante peut être résumée dans le tableau suivant :

Résumé

Passons en revue ce que vous avez appris dans ce laboratoire :

• Les différentes façons de déclarer des variables
• Les différentes façons d’initialiser des variables
• Le concept de durée de vie des variables
• L’utilisation des constantes et la validité de leurs déclarations

Dans ce laboratoire, nous avons étudié l’utilisation de base des variables en Go, présenté différentes façons de déclarer et d’utiliser des variables selon les situations, et introduit les constantes.