Introduction
Dans les leçons précédentes, nous avons étudié les variables en Go. Dans cette session, nous allons explorer le concept de constantes, apprendre à les utiliser et comprendre leur importance. Plongeons dans l'univers des constantes.
Points de connaissance :
- Qu'est-ce qu'une constante
- Déclarer des constantes
- Le générateur de constantes
iota - Utilisation des constantes
Qu'est-ce qu'une constante ?
En termes simples, une constante est une valeur déclarée qui ne peut pas être modifiée pendant l'exécution du programme. Les constantes permettent au compilateur de connaître leurs valeurs avant même l'exécution, dès la phase de compilation.
Les déclarations de constantes se voient attribuer des valeurs spécifiques. Leur syntaxe est similaire à celle des variables, mais une fois qu'une valeur de constante est définie, elle devient immuable.
Les constantes sont particulièrement utiles lorsque vous souhaitez déclarer une valeur qui ne doit jamais changer, comme l'adresse d'un site web ou une valeur mathématique précise comme π.
Déclarer des constantes
La déclaration des constantes ressemble beaucoup à celle des variables. Le mot-clé var est simplement remplacé par le mot-clé const.
Remarque : Les constantes doivent impérativement se voir assigner une valeur lors de leur déclaration.
En Go, toutes les variables définies doivent être utilisées sous peine d'erreur, mais les constantes font exception à cette règle. Même si elles ne sont pas utilisées, le compilateur ne signalera aucune erreur.
La syntaxe pour déclarer une constante est la suivante :
const name [type] = value
name est le nom de la constante. type représente le type de données, mais il peut être omis car Go est capable de l'inférer automatiquement. La valeur à la fin est celle assignée à la constante.
Notez que seuls les types suivants peuvent être utilisés pour des déclarations de constantes :
- Types entiers (integers)
- Types à virgule flottante (floats)
- Types complexes
- Types booléens
- Types chaînes de caractères (strings)
Voyons un exemple. Créez un nouveau fichier nommé const.go dans le répertoire ~/project :
touch ~/project/const.go
Saisissez le code suivant dans const.go :
package main
import "fmt"
// Déclarer une seule constante
const labex string = "LabEx" // spécifie explicitement le type string
const labs = "LABS" // type inféré automatiquement comme string par le compilateur
// Déclarer plusieurs constantes
const (
hangzhou, chengdu = "HANGZHOU", "CHENGDU"
monday, tuesday, wednesday = "MONDAY", "TUESDAY", "WEDNESDAY"
)
func main() {
fmt.Printf("Le type de labex est : %T, et sa valeur est %s\n", labex, labex)
fmt.Printf("Le type de labs est : %T, et sa valeur est %s\n", labs, labs)
fmt.Println()
fmt.Println(hangzhou, chengdu)
fmt.Println(monday, tuesday, wednesday)
}
go run ~/project/const.go
Après l'exécution du programme, le résultat est le suivant :
Le type de labex est : string, et sa valeur est LabEx
Le type de labs est : string, et sa valeur est LABS
HANGZHOU CHENGDU
MONDAY TUESDAY WEDNESDAY
Ici, nous illustrons la déclaration de constantes uniques et multiples. Lors de la déclaration de plusieurs constantes, il est recommandé d'utiliser des parenthèses pour une meilleure lisibilité.
Dans ce programme, nous n'avons montré que des constantes de type chaîne de caractères. Cependant, les constantes peuvent adopter d'autres types, comme les entiers ou les booléens.
Lors de la déclaration de plusieurs constantes à l'aide de parenthèses, si une constante n'est pas initialisée, elle héritera de la valeur de la constante précédente.
Saisissez le code suivant dans const.go :
package main
import "fmt"
const (
monday = "MONDAY"
tuesday = "TUESDAY"
wednesday = "WEDNESDAY"
thursday
friday
)
func main() {
fmt.Println(monday, tuesday, wednesday, thursday, friday)
}
go run ~/project/const.go
Le résultat est le suivant :
MONDAY TUESDAY WEDNESDAY WEDNESDAY WEDNESDAY
Ici, thursday et friday n'ont pas de valeurs explicites. Selon les règles de Go, lorsqu'une constante n'est pas explicitement initialisée dans un bloc, elle hérite de la valeur de la constante précédente. Dans ce cas précis :
thursdayhérite de la valeur dewednesday.fridayhérite également de la valeur dewednesday.
Ce comportement permet d'écrire un code concis, mais peut entraîner des résultats inattendus si vous n'y prêtez pas attention.
Si vous voulez que thursday et friday aient des valeurs distinctes, vous devez les assigner explicitement :
const (
monday = "MONDAY"
tuesday = "TUESDAY"
wednesday = "WEDNESDAY"
thursday = "THURSDAY"
friday = "FRIDAY"
)
Cela produira le résultat attendu :
MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY
Le générateur de constantes iota
En plus de déclarer les constantes une par une, nous pouvons utiliser iota pour les déclarer par lots de manière séquentielle. Voyons un exemple. Écrivez le code suivant dans le fichier const.go :
package main
import "fmt"
const (
monday = iota // valeur initiale : 0
tuesday = iota // s'incrémente de 1 à chaque fois
wednesday = iota
thursday = iota
friday = iota
)
func main() {
fmt.Println(monday, tuesday, wednesday, thursday, friday)
}
go run ~/project/const.go
Le résultat est le suivant :
0 1 2 3 4
Lors de l'utilisation de iota, la valeur initiale est 0 et elle augmente de 1 pour chaque élément suivant dans le bloc de constantes.
Une fois le premier élément déclaré avec iota, les constantes suivantes n'ont plus besoin d'être explicitement assignées. Le code suivant fonctionnera tout aussi bien :
package main
import "fmt"
const (
monday = iota // 0
tuesday // 1
wednesday // 2
thursday // 3
friday // 4
)
func main() {
fmt.Println(monday, tuesday, wednesday, thursday, friday)
}
Et si nous voulons sauter une valeur spécifique ? Dans ce cas, nous pouvons utiliser le caractère de soulignement (underscore). Le code suivant ignore la constante pour mercredi :
package main
import "fmt"
const (
monday = iota // 0
tuesday // 1
_
thursday // 3
friday // 4
)
func main() {
fmt.Println(monday, tuesday, thursday, friday)
}
go run ~/project/const.go
Comme vous pouvez le voir, le résultat est le suivant :
0 1 3 4
L'opérateur iota peut également être utilisé pour des opérations arithmétiques. Saisissez le code suivant dans const.go :
package main
import "fmt"
const (
a = iota // 0
b = iota * 3 // 1 * 3
c = iota + 4 // 2 + 4
)
const (
B = 1 << (iota * 10) // équivaut à 1 << (0 * 10)
KB // 1024
MB // 1048576
)
func main() {
fmt.Println(a, b, c)
fmt.Println(B, KB, MB)
}
go run ~/project/const.go
Le résultat est le suivant :
0 3 6
1 1024 1048576
Dans le premier bloc de déclarations, nous utilisons iota pour effectuer des opérations arithmétiques simples.
Dans le second bloc, nous utilisons iota avec l'opérateur de décalage à gauche << pour exprimer les valeurs de 1 KB et 1 MB en octets (B). Par exemple, 1 KB est égal à 1024B, et 1 MB est égal à 1024 * 1024, soit 1048576B.
Quiz
Renforçons maintenant ce que nous avons appris. Créez un nouveau fichier nommé iota.go et utilisez iota ainsi que des constantes pour afficher les valeurs de 1 Go (GB) et 1 To (TB) exprimées en octets (B).
Exigences :
- Ne pas afficher directement les nombres convertis. Utilisez
iotapour effectuer la conversion. - Le fichier
iota.godoit être situé dans le répertoire~/project.
Astuce : Vous pouvez vous référer au code de la section "iota".
Le format de sortie attendu est le suivant :
1GB is equal to 1073741824B
1TB is equal to 1099511627776B
Résumé
Récapitulons ce que nous avons appris dans cette leçon :
- Les constantes ne peuvent pas être modifiées après leur déclaration.
- Les constantes sont déclarées à l'aide du mot-clé
const. - Lors de la déclaration de plusieurs constantes, l'usage des parenthèses est préférable.
- Le générateur de constantes
iotapermet de créer des énumérations de valeurs. iotapeut également être intégré dans des opérations arithmétiques.
Dans cette leçon, nous avons exploré les constantes et introduit le générateur iota. Les chaînes de caractères, les entiers, les nombres à virgule flottante et les constantes constituent les types de données fondamentaux en Go.
