Quelles sont les variables et constantes en Go ? Expliqué avec des exemples

Les variables et les constantes sont des concepts fondamentaux dans la plupart des langages de programmation. Ils constituent les blocs de construction pour le stockage et la gestion des données.

Dans cet article, nous allons examiner comment fonctionnent les variables et les constantes en Go.

Table des matières :

• Qu’est-ce qu’une Variable ?

• Comment Créer une Variable

• Déclaration Explicite

• Déclaration de Variable Abrégée

• Déclarations de Variables Multiples

• Valeurs Zéro

• Qu’est-ce qu’une Portée de Variable

• Conventions de Nomage en Go

• Quels sont les Constantes en Go

• Comment Déclarer des Constantes en Go

• Type de Constantes en Go

• C’est tout pour aujourd’hui

Qu’est-ce que les Variables ?

Une variable est un emplacement de stockage identifié par un nom (ou un identifiant) qui contient une valeur. Cette valeur peut changer (ou varier) pendant l’exécution d’un programme. C’est pourquoi on l’appelle une variable.

Par exemple :

myName := “temitope”

fmt.Println(myName)

myName:= ”oyedele”

fmt.Println(myName)

Nous avons créé une variable avec un identifiant myName qui contient une valeur de chaîne de caractères.

Si vous avez remarqué, nous avons changé la valeur pour une autre chaîne, et nous pouvons le faire plusieurs fois car les variables le permettent.

Les variables vous permettent de stocker des données, qui peuvent être de différents types, tels que des entiers, des nombres à virgule flottante, des chaînes de caractères ou des objets.

Comment Créer une Variable en Go

Il existe deux façons principales de créer une variable en Go, la déclaration explicite et la déclaration abrégée.

Déclaration Explicite

C’est la façon traditionnelle de créer une variable en Go. Elle fonctionne en utilisant le mot-clé var et en déclarant le type de variable, rendant ainsi votre code plus lisible et clair.

package main

import "fmt"

func main() {

    var age int = 25

    var name string = "Temitope"

    var height float64 = 5.7

    fmt.Println(age, name, height)

}

Vous pouvez voir que, pour chaque variable, nous avons déclaré son type de données avant d’assigner une valeur à elle.

output:
25 Temitope 5.7

Le mot-clé var et le type de données peuvent également être utilisés sans valeur initiale :

package main

import "fmt"

func main() {
    var age int
    var name string
    var height float64

    age = 25
    name = "Temitope"
    height = 5.7

    fmt.Println(age, name, height)
}

Cette méthode permet de déclarer d’abord les variables sans valeur initiale. Elles seront ensuite affectées plus tard dans le code. Vous aurez toujours la même sortie que pour la première méthode.

Déclaration de Variable Abrégée

La syntaxe de déclaration de variable abrégée (:=) est une manière plus concise de déclarer des variables. Cette méthode permet de déclarer et d’initialiser une variable en une seule ligne sans indiquer explicitement son type, car le type est déduit de la valeur assignée.

package main

import "fmt"

func main() {

    age := 25

    name := "Temitope"

    height := 5.7

    fmt.Println(age, name, height)

}

Ici, chaque variable a été déclarée avec sa valeur, Go déduisant le type de donnée. Par exemple, age a été déclaré et initialisé avec une valeur de 25, et Go a déduit son type comme int. name a été déclaré avec la valeur « Temitope », et Go a déduit son type comme string. Enfin, height a été déclaré avec 5.7, et Go a déduit son type comme float64.

output:
25 Temitope 5.7

Un des inconvénients de la déclaration de variable abrégée est que vous ne pouvez l’utiliser qu’à l’intérieur d’une fonction.

Déclarations de Variables Multiples

Vous pouvez déclarer et initialiser plusieurs variables sur la même ligne en séparant chaque variable par une virgule. Cette approche est simple et directe. Elle est couramment utilisée lorsque les variables sont liées ou lorsque vous souhaitez les initialiser ensemble. Par exemple:

package main

import "fmt"

func main() {

    var age, height int = 25, 180

    var name, city string = "Temitope", "New York"

    fmt.Println(age, height)

    fmt.Println(name, city)
}

Ici, les variables age et height sont toutes deux déclarées comme des entiers et initialisées avec les valeurs 25 et 180, respectivement. Les variables name et city sont également toutes deux déclarées comme des chaînes de caractères et initialisées avec « Temitope » et « New York »:

Output:
25 180
Temitope New York

Vous pouvez également déclarer plusieurs variables dans un bloc comme suit:

package main

import "fmt"

func main() {

    var (
        age int = 25

        name string = "Temitope"

        height int = 180

        city string = "New York"
    )

    fmt.Println(age, name, height, city)

}

Ici, les variables age, name, height, et city sont déclarées dans un seul bloc var, chaque variable ayant sa propre ligne.

Output:
25 Temitope 180 New York

Les valeurs zéro

Quand des variables sont déclarées sans être initialisées, elles reçoivent par défaut des valeurs zéro. Ces valeurs diffèrent en fonction du type de variable. Voici un exemple de la déclaration de valeurs par défaut :

package main

import "fmt"

func main() {

    var intValue int

    var floatValue float64

    var boolValue bool

    var stringValue string

    var ptrValue *int

    var sliceValue []int

    var mapValue map[string]int

    fmt.Println("Zero values:")

    fmt.Println("int:", intValue)

    fmt.Println("float64:", floatValue)

    fmt.Println("bool:", boolValue)

    fmt.Println("string:", stringValue)

    fmt.Println("pointer:", ptrValue)

    fmt.Println("slice:", sliceValue)

    fmt.Println("map:", mapValue)

}

Dans le code ci-dessus, voici ce qui va se passer :

• L’entier intValue recevra la valeur zéro 0.

• Le nombre à virgule flottante floatValue recevra la valeur zéro 0.

• Le booléen boolValue recevra la valeur zéro false.

• La chaîne de caractères stringValue recevra la valeur zéro «  » (chaîne vide).

• Le pointeur ptrValue, la tranche sliceValue, et la carte mapValue recevront tous la valeur zéro nil.

Sortie :

Output:
Zero values:
int: 0
float64: 0
bool: false
string: 
pointer: <nil>
slice: []
map: map[]

Qu’est-ce qu’une Portée de Variable ?

Les variables peuvent être déclarées soit globalement soit localement. La portée d’une variable détermine où elle peut être accédée et modifiée dans votre code.

Les variables globales sont déclarées en dehors de toute fonction, généralement au sommet d’un fichier, et elles peuvent être accédées par n’importe quelle fonction du même package. Voici un exemple :

package main

import "fmt"

var globalCounter int = 0

func incrementCounter() {

    globalCounter++

}

func main() {

    fmt.Println("Initial Counter:", globalCounter)

    incrementCounter()

    fmt.Println("After Increment:", globalCounter)

}

Dans l’exemple ci-dessus, globalCounter est la variable globale, et elle est accessible à la fois par la fonction incrementCounter et la fonction main.

De plus, la valeur de globalCounter persiste entre les appels de fonctions. Cela signifie que tout changement apporté à cette variable dans une fonction aura une incidence sur sa valeur dans d’autres parties du programme.

En revanche, les variables locales sont déclarées à l’intérieur d’une fonction ou d’un bloc et sont uniquement accessibles dans cette fonction ou ce bloc spécifique. Elles sont créées lorsque la fonction ou le bloc est exécuté et détruites une fois que celui-ci est terminé. Par exemple :

package main

import "fmt"

func incrementCounter() {

    localCounter := 0

    localCounter++

    fmt.Println("Local Counter:", localCounter)

}

func main() {

    incrementCounter()

    incrementCounter()

}

Dans le code ci-dessus, nous avons la localCounter comme variable locale à l’intérieur de la fonction incrementCounter. Chaque fois que incrementCounter est appelée, une nouvelle localCounter est créée, initialisée à 0, puis incrémentée.

La valeur de localCounter n’est pas conservée entre les appels de fonctions, de sorte qu’elle ne peut pas affecter n’importe quelle partie du programme lors d’un changement apporté à la fonction.

Conventions de nommage en Go

Le nommage correct des variables est crucial pour écrire un code propre, lisible et maintainable. Go a certaines conventions et règles spécifiques pour le nommage des variables. Voici quelques-unes d’entre elles :

• Utilisez des noms descriptifs : Utilisez des noms qui clairement décrivent la finalité ou le contenu de la variable. Par exemple, plutôt que d’utiliser des noms vagues comme x ou y, utilisez des noms comme age, prixTotal ou nomUtilisateur qui indiquent clairement ce que représente la variable.

• Utilisez le CamelCase pour les noms composés de plusieurs mots : En Go, il est courant d’utiliser le camelCase pour les noms de variables composés de plusieurs mots. Le premier mot est en minuscule et la première lettre de chaque mot suivant est en majuscule.

• Évitez d’utiliser des underscores : Contrairement à d’autres langages, Go préfère le camelCase plutôt que d’utiliser des underscores pour séparer les mots dans les noms de variables. Restez sur le camelCase pour respecter le style idiomatique de Go.

• Utilisez des noms courts pour les variables de courte durée : Pour les variables de courte durée, telles que les compteurs ou indices de boucles, il est acceptable d’utiliser des noms courts comme i, j ou k.

Qu’est-ce que les constantes en Go ?

Les constantes sont des valeurs immuables définies à la compilation qui ne peuvent être modifiées pendant l’exécution du programme. Elles sont utiles pour définir des valeurs connues à l’avance et qui resteront les mêmes.

Imaginez que vous construisez une plateforme de vente en ligne où le frais de livraison standard est toujours de 10 $US. Vous pouvez les déclarer comme des constantes, de sorte que vous pouvez les utiliser dans votre programme dans le cas où des frais de livraison doivent être appliqués. Si les taux de livraison changent, vous devez simplement mettre à jour la valeur en un seul endroit.

Comment déclarer des constantes en Go ?

Vous pouvez déclarer des constantes en utilisant le mot-clé const, suivi du nom, du type (facultatif si la valeur implique le type) et de la valeur de la constante. Voici comment :

package main

import "fmt"

func main() {

    const pi float64 = 3.14159

    const greeting string = "Hello, World!"

    fmt.Println("Pi:", pi)

    fmt.Println("Greeting:", greeting)

}

Si vous essayez de modifier une constante après sa déclaration, vous obtiendrez une erreur de compilation.

Types de constantes en Go

Les constantes peuvent être catégorisées comme typées ou non typées. Les deux types de constantes servent le même objectif. Ils fournissent des valeurs fixes et immuables tout au long du programme. Cependant, ils diffèrent sur la façon dont Go traite leurs types et sur la flexibilité qu’ils offrent lors de leur utilisation.

Les constantes non typées ne sont pas assignées à un type à moins qu’elles ne soient utilisées dans un contexte qui exige un type. Lorsque vous déclarez une constante non typée, Go déduit le type à la point où la constante est utilisée. Cela rend les constantes non typées plus flexibles car elles peuvent être utilisées dans un nombre de déclinaisons sans nécessiter de conversion de type.

package main

import "fmt"

const gravity = 9.81

func main() {

    var height int = 10

    var acceleration float64 = gravity * float64(height)

    fmt.Println("Acceleration:", acceleration)

}

Ici, gravity est la constante non typée. Cela signifie que Go peut déduire son type en fonction de la manière dont elle est utilisée. Lorsque gravity est utilisée dans une calcul avec un float64, Go traitera automatiquement comme un float64.

Contrairement aux constantes non typées, les constantes typées ont un type explicitement déclaré. Cela signifie qu’elles ne peuvent être utilisées que dans des contextes qui correspondent à ce type ou qui peuvent être convertis vers un type compatible. Les constantes typées sont plus strictes, garantissant que la valeur est toujours traitée comme le type spécifique déclaré.

package main

import "fmt"

const speedOfLight int = 299792458

func main() {

    var distance int = speedOfLight * 2

    fmt.Println("Distance:", distance)

}

Ici, speedOfLight est la constante typée avec le type int.

Elle ne peut être utilisée que dans des opérations avec d’autres valeurs de int ou convertie explicitement vers un autre type.

C’est tout pour aujourd’hui

Dans cet article, nous avons examiné ce que sont les variables et les constantes et comment les déclarer en Go.

Les variables et les constantes sont des outils essentiels en programmation. Elles permettent aux développeurs de gérer et de manipuler les données de manière efficiente. Lorsque vous comprenez comment les utiliser, vous pouvez améliorer la qualité de votre code.

Veuillez partager si vous avez trouvé cela utile.