Introduction aux variables en Go

Introduction

Pourquoi avons-nous besoin de variables dans les langages de programmation informatique? C'est une question ancienne. Tout comme nous pouvons nous souvenir que l'URL de LabEx est labex.io, les programmes informatiques ont également besoin de mémoriser certaines données pour leur utilisation.

Le but des variables est de représenter une donnée. Dans cette section, nous allons explorer comment les variables sont utilisées dans le langage Go.

Points de connaissance :

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

Skills Graph

Qu'est-ce qu'une variable?

Qu'est-ce qu'une variable? En termes simples, une variable est un conteneur utilisé pour stocker une donnée modifiable.

Dans les langages compilés tels que Go, le type d'une variable est fixe.

Qu'est-ce que cela signifie qu'un type de variable soit fixe?

Cela signifie qu'une variable ne peut contenir qu'un seul type de donnée. En d'autres termes, les éléments stockés dans le conteneur de la variable sont fixes.

Si une variable est utilisée pour contenir des fruits, elle ne devrait contenir que des fruits. Une fois que le conteneur a contenu des fruits, il ne peut pas être utilisé pour contenir des biscuits. Cela se reflète dans le code en ce sens qu'une variable ne peut pas être assignée avec deux types de données différents.

Modifiabilité des variables

Comme son nom l'indique, la valeur d'une variable peut changer, tant que le changement ne dépasse pas la plage autorisée par son type.

Le langage Go a les règles suivantes pour les variables :

• Le nom doit être composé de lettres, de chiffres et de caractères de soulignement (underscores).
• L'identifiant de la variable ne peut pas commencer par un chiffre.
• L'identifiant ne peut pas être un mot clé réservé. Vérifier les mots clés réservés
• Les noms de variables sont sensibles à la casse, mais il n'est pas recommandé d'utiliser des majuscules différentes pour distinguer deux variables ayant le même nom.

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

Dans le langage Go, le mot clé utilisé pour déclarer des variables de manière générale est var.

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

var nomDeVariable typeDeVariable.

Quels sont les types de variables courants en Go?

Étant donné que les types de variables ne sont pas le focus de cette section, seuls les trois types les plus courants sont listés.

Plus de types seront expliqués dans les cours suivants.

Comment déclarer une variable?

Maintenant, déclarons une variable de type entier nommée a.

var a int

Comment le retenir? Vous pouvez vous dire mentalement :

Définir une variable nommée `a`, qui est de type int.

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

Cette façon de déclarer des variables 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, veuillez vous référer à la documentation officielle.

Quel nom donner à une variable?

Un bon nom de variable devrait indiquer clairement le sens de la variable.

Lors de la nomination des variables, nous devons nous attarder à leur expressivité et éviter d'utiliser des abréviations.

Ici, nous allons brièvement présenter la méthode de base de nomination des variables : la convention de nommage en camel case.

La convention de nommage en camel case utilise des lettres en minuscules et en majuscules pour représenter une variable. Le premier mot est en minuscules, et la première lettre de chaque mot suivant est en majuscule.

Par exemple : currentDate. Le premier mot, current, est en minuscules, et le deuxième mot, Date, commence par une majuscule.

De cette façon, une variable qui représente la date actuelle est facilement compréhensible.

Cette convention de nommage est généralement utilisée pour les variables importantes et couramment utilisées, tandis que les variables temporaires peuvent être simplifiées tant qu'elles ne causent pas de doublons.

Méthode de déclaration par lots

Maintenant, déclarons trois variables :

var a int // Déclare une variable entière nommée a
var b int // Déclare une variable entière nommée b
var c int // Déclare une variable entière nommée c

Les étudiants attentifs auront peut-être remarqué que les trois variables, a, b et c, sont de type int.

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

var a, b, c int // Déclare trois variables a, b, c comme des entiers

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

var a int    // Déclare une variable entière nommée a
var b string // Déclare une variable chaîne de caractères nommée b
var c bool   // Déclare une variable booléenne nommée c

Nous semblons avoir rencontré une situation similaire lors de l'importation de packages. De nombreux packages avec des noms différents doivent être importés ensemble, nous pouvons donc utiliser une méthode d'écriture similaire :

var (
    a int
    b string
    c bool
)

Notez que ce type de déclaration similaire à l'importation de packages est généralement utilisé pour définir des variables globales.

Initialisation par défaut

En Go, toutes les variables reçoivent des valeurs initiales lorsqu'elles sont déclarées. Explorons quelles sont les valeurs initiales des variables!

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

touch ~/project/varExercise.go

Écrivez le code suivant dans le 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 essayer de l'exécuter vous-même et voir si cela correspond au tableau ci-dessous.

go run varExercise.go

Les types de valeurs initiales sont résumés comme suit :

Initialisation standard

Étant donné que le type d'une variable peut être déterminé par sa valeur initiale, pouvons-nous changer la valeur par défaut ou celle 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 avoir déclaré la variable, suivi d'une valeur initiale compatible avec le type de la variable. Si vous souhaitez changer la valeur, utilisez simplement le nom de la variable suivi de = et d'une autre valeur du même type.

Modifiez le fichier varExercise.go :

package main

import "fmt"

func main() {
    // Déclarer et initialiser
    var a int = 1
    var b string = "labex"
    var c bool = true

    // Afficher les variables
    fmt.Println("Avant modification :")
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)

    // Modifier les variables
    a = 233
    b = "labex"
    c = false

    // Afficher les variables modifiées
    fmt.Println("Après modification :")
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

Après avoir exécuté le code, la sortie est la suivante :

$ go run varExercise.go
Avant modification :
1
labex
true
Après modification :
233
labex
false

Vous pouvez essayer de l'exécuter vous-même et modifier les valeurs initiales.

Nous avons mentionné que la valeur initiale assignée à une variable doit être du même type que celui de la déclaration de la variable. Que se passe-t-il si les types sont différents?

Par exemple, assignons "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 l'exemple, nous ne pouvons pas assigner un type chaîne de caractères tel que "labex" à une variable de type int. En effet, Go est un langage compilé fortement typé et le code ne peut pas être compilé.

Déclaration de type par inférence

Étant donné que Go peut déterminer le type d'une variable à partir de sa valeur initiale, pouvons-nous simplifier le processus de déclaration de type en éliminant l'étape de spécification explicite du type?

package main

import "fmt"

func main() {
    // var a int = 1
    var a = 1 // Le type est inféré
    fmt.Println(a)
}

Maintenant, vous n'avez même pas besoin d'utiliser le mot clé var pour définir une variable.

Cette façon de déclarer et d'initialiser une variable peut également être combinée avec la méthode de déclaration par lots :

a, b, c := 0
// Déclare les variables a, b, c comme des entiers et assigne une valeur initiale de 0
a, b, c := 0, "", true
// Déclare les variables a, b, c respectivement comme entier, chaîne de caractères et booléen

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

Parfois, nous écrivons le code suivant :

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

Le compilateur vous indiquera qu'il y a une erreur dans le code car la variable a a été redéclarée. Cependant, si vous l'écrivez de la manière suivante :

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

Il y a une telle sortie car l'a de valeur 1 ci-dessus et l'a de valeur 2 ci-dessous ne sont pas dans la même portée de variable (à l'intérieur des mêmes accolades), donc le compilateur les considère comme deux variables différentes.

Le compilateur ne vous indiquera pas votre erreur, mais il y aura des sorties inattendues.

En Go, il est stipulé que :

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

Par conséquent, la déclaration courte de variable ne peut être utilisée que pour déclarer des variables locales et ne peut pas être utilisée pour déclarer des variables globales.

Alors, qu'est-ce qu'une variable globale et qu'est-ce qu'une variable locale?

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

Portée des variables

La portée d'une variable fait référence à la plage dans laquelle une variable dans un programme est valide, c'est-à-dire comment elle peut être utilisée.

Vous avez certainement remarqué que si vous déclarez une variable sans l'utiliser, le code ne sera pas compilé.

En d'autres termes, lors de la compilation de Go, il vérifie si chaque variable a été utilisée, c'est-à-dire si elle a été utilisée dans sa portée.

Nous pouvons simplement diviser les variables en trois types en fonction de leur position de déclaration :

• Les variables définies à l'intérieur d'une fonction, appelées variables locales
• Les variables définies en dehors d'une fonction, appelées variables globales
• Les variables définies à l'intérieur d'une définition de 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() { // Corps de la fonction
    var a int = 1 // Variable locale
    fmt.Println(a)
}

Les variables locales sont définies à l'intérieur du corps de la fonction, comme a définie à l'intérieur de la fonction main. La portée de la variable a est limitée à l'intérieur de la fonction main.

En même temps, si la variable n'est pas utilisée dans la fonction main, le compilateur lancera une erreur.

Variables globales

Cependant, il est également possible de définir une variable globale.

package main

import "fmt"

var a int = 1 // Variable globale
func main() { // Corps de la fonction
    fmt.Println(a)
}

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

Vous pouvez vous demander pourquoi les variables globales ne produisent pas d'erreurs même si elles ne sont pas appelées.

Les détails concernant les variables de paramètres formels seront expliqués dans les cours ultérieurs liés aux fonctions.

Durée de vie des variables

Les oiseaux qui s'envolent, cachent leur parcours. Les lapins rusés meurent, et les chiens de chasse seront mijotés. - Records of the Grand Historian

Lorsqu'une variable a accompli son but, elle devrait être détruite pour réduire l'utilisation de la mémoire.

• Variables globales : La durée de vie d'une variable globale est cohérente avec la durée d'exécution de l'ensemble du programme. Lorsque le programme cesse de fonctionner, la variable globale est supprimée de la mémoire.
• Variables locales : Lorsqu'il n'y a plus de moyen d'accéder à une variable, son espace mémoire sera récupéré.

Une telle conception est la clé de la haute performance et de l'utilisation efficace de l'espace de Go.

Au cours de la durée de vie d'une variable, elle 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 // Variable locale, la durée de vie est limitée à l'ensemble de la fonction main
    var a int = 2 // Redéfinition
    fmt.Println(a)
}

Après avoir exécuté le 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 est redéfini.

Constantes

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

Si une variable ne changera pas pendant toute la durée d'exécution du programme, alors nous devrions la définir comme une constante.

Les constantes sont très similaires aux variables, et vous pouvez même les considérer comme des variables dont la valeur est immuable.

Lors de la déclaration d'une constante, nous n'avons qu'à remplacer le mot clé var par le mot clé const.

const Pi = 3.14159 // Utilisation de l'initialisation par inférence de type

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

package main

import "fmt"

func main() {
    const Pi = 3.14159
    Pi = 2 // Erreur : impossible d'affecter une valeur à 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.

Et la valeur initiale assignée à une constante doit être fixe au moment de la compilation.

Les valeurs de retour de fonctions définies par l'utilisateur ne sont pas considérées comme fixes en Go.

var a int = 1
// La valeur est fixe, la déclaration est valide.
const Pi = 3.14159
// La valeur calculée est également fixe, la déclaration est valide.
const c = 1 / Pi
// La valeur de retour fixe d'une fonction intégrée est valide.
const le = len("labex")
// La valeur de retour de la fonction définie par l'utilisateur n'est pas fixe, la déclaration est invalide.
const le = getLen("labby")
// `a` est une valeur variable qui n'est pas fixe, la déclaration est invalide.
const k = a

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

Résumé

Revoyons ce que nous avons appris dans ce laboratoire :

• Les méthodes de déclaration de variables
• Les méthodes d'initialisation de 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 revu l'utilisation de base des variables en Go, démontré les méthodes de déclaration et d'utilisation des variables dans différentes situations, et introduit les constantes.