1. Variables et constantes

En Golang, les variables et les constantes sont deux concepts fondamentaux qui jouent un rôle très important dans un programme.

  • Une variable est un identificateur nommé utilisé pour stocker des données dans un programme. En Golang, le mot-clé var est utilisé pour déclarer des variables.
  • Une constante est un identificateur dont la valeur ne peut pas être modifiée dans le programme. En Golang, le mot-clé const est utilisé pour déclarer des constantes.

2 Déclaration et initialisation des variables Golang

2.1 Déclaration et affectation d'une seule variable

En langage Go, le mot-clé var est utilisé pour déclarer une variable avec le format var nom_variable type. Après la déclaration, la variable peut se voir attribuer une valeur dans le code suivant, ou elle peut être directement initialisée au moment de la déclaration. Par exemple :

var age int // Déclarer une variable entière age
age = 25    // Affecter une valeur à la variable

var name string = "Alice" // Déclarer et initialiser la variable name

2.2 Déclaration de multiples variables

Le langage Go prend en charge la déclaration simultanée de plusieurs variables, ce qui peut rendre le code plus concis. La déclaration en bloc est généralement effectuée au début d'une fonction ou au niveau du package. Par exemple :

var (
    firstName, lastName string
    age                 int
)

firstName = "John"
lastName = "Doe"
age = 30

Dans la déclaration en bloc ci-dessus, firstName et lastName sont déclarés comme des chaînes de caractères, tandis que age est un entier.

2.3 Inférence de type et déclaration de variables courtes

En langage Go, il n'est pas toujours nécessaire de spécifier explicitement le type de la variable. Si une expression d'initialisation est fournie lors de la déclaration d'une variable, Go peut en déduire le type de la variable. C'est ce qu'on appelle l'inférence de type. La déclaration de variables courtes utilisant := peut simplifier l'instruction de déclaration et d'initialisation des variables basée sur l'inférence de type. Par exemple :

city := "Pékin" // Utilisation de la déclaration de variable courte pour déclarer et initialiser simultanément city
country := "Chine" // Le pays est inféré comme un type string

Il convient de noter que les déclarations de variables courtes ne peuvent être utilisées qu'à l'intérieur des fonctions et ne peuvent pas être utilisées à une portée globale.

2.4 Déclaration de variables en dehors des fonctions

Les variables déclarées en dehors des fonctions ont une portée au niveau du package. Ces variables sont visibles et accessibles dans l'ensemble du package. Par exemple :

var globalVar string = "Je suis global" // Déclaration d'une variable globale

func printGlobalVar() {
    fmt.Println(globalVar) // Accéder à la variable globale à l'intérieur de la fonction
}

Les variables globales peuvent être partagées entre toutes les fonctions dans le package, mais elles doivent être utilisées avec précaution pour éviter les conflits de nomenclature potentiels et les références peu claires.

Astuce : Comprendre le code de fonction de base ici est suffisant, des explications détaillées des fonctions seront fournies dans les sections ultérieures.

3 Types de données de base et valeurs nulles

3.1 Types de données de base en Golang

En langage Go, chaque type de variable fournit des sémantiques explicites et des caractéristiques comportementales. Voici quelques types de données de base courants :

  • int, int8, int16, int32, int64 : Différentes plages d'entiers
  • uint, uint8, uint16, uint32, uint64 : Entiers non signés
  • float32, float64 : Nombres à virgule flottante
  • bool : Valeurs booléennes (true ou false)
  • string : Chaînes de caractères

3.2 Concept de valeurs nulles

En langage Go, les variables sont automatiquement initialisées à la valeur nulle de leur type après la déclaration. La valeur nulle fait référence à la valeur par défaut du type correspondant lorsqu'une variable n'est pas explicitement initialisée. Ceci n'est pas courant dans certains autres langages, mais en Go, cela garantit que toutes les variables ont toujours une valeur initiale valide. Voici les valeurs nulles pour chaque type de données de base :

  • La valeur nulle pour un entier est 0
  • La valeur nulle pour un nombre à virgule flottante est 0.0
  • La valeur nulle pour un booléen est false
  • La valeur nulle pour une chaîne de caractères est une chaîne vide ""

Par exemple :

var i int     // La valeur nulle est 0
var f float64 // La valeur nulle est 0.0
var b bool    // La valeur nulle est false
var s string  // La valeur nulle est ""

Comprendre le concept de valeurs nulles est très important, car cela peut aider les développeurs à comprendre le comportement de l'initialisation des variables et peut être utilisé pour éviter les erreurs de pointeur nul ou non initialisé.

4 Portée des variables

4.1 Variables Locales

Les variables locales sont des variables définies à l'intérieur d'une fonction et ne peuvent être accessibles qu'à l'intérieur de cette fonction. Les paramètres de la fonction appartiennent également aux variables locales. Dès leur création et jusqu'à ce que l'exécution de la fonction soit complète, les variables locales seront supprimées. À chaque appel d'une fonction, les variables locales sont recréées.

func exempleVariableLocale() {
    var variableLocale int = 10 // Ceci est une variable locale
    fmt.Println(variableLocale)
}

func main() {
    exempleVariableLocale() // Sortie : 10
    // fmt.Println(variableLocale) // Cela provoquera une erreur de compilation car variableLocale n'est pas visible ici
}

Dans l'exemple ci-dessus, variableLocale ne peut être accessible qu'à l'intérieur de la fonction exempleVariableLocale.

4.2 Variables Globales

Les variables globales sont des variables définies en dehors des fonctions et peuvent être accessibles dans n'importe quel fichier du même package. Si vous souhaitez utiliser des variables globales dans d'autres packages, le nom de la variable doit commencer par une lettre majuscule, conformément aux règles de contrôle d'accès de Go.

package main

import "fmt"

var variableGlobale int = 20 // Ceci est une variable globale

func main() {
    fmt.Println(variableGlobale) // Sortie : 20
    changerGlobal()
    fmt.Println(variableGlobale) // Sortie : 30
}

func changerGlobal() {
    variableGlobale = 30 // Changer la valeur de la variable globale
}

Dans cet exemple, variableGlobale est visible à la fois dans la fonction main et dans la fonction changerGlobal.

5 Déclaration et Utilisation de Constantes

5.1 Le mot-clé const

Nous utilisons le mot-clé const pour définir des constantes. Les constantes sont des valeurs qui ne peuvent pas être modifiées et une fois définies, leur valeur ne peut pas être modifiée. Les constantes peuvent être de n'importe quel type de données de base tel que les entiers, les nombres à virgule flottante, les booléens ou les chaînes de caractères.

const Pi = 3.14 // Déclarer une constante float
const StrConst string = "Bonjour, le Monde !" // Déclarer une constante de chaîne de caractères

func main() {
    fmt.Println(Pi)
    fmt.Println(StrConst)
}

5.2 Constantes Enumérées

Le langage Go n'a pas de type énumération spécifique, mais vous pouvez utiliser le mot-clé iota pour obtenir une énumération. À l'intérieur d'un bloc const, chaque déclaration de constante supplémentaire fera augmenter la valeur de iota de 1.

const (
    Dimanche = iota  // 0
    Lundi         // 1
    Mardi        // 2
    Mercredi      // 3
    Jeudi       // 4
    Vendredi         // 5
    Samedi       // 6
)

func main() {
    fmt.Println(Dimanche)    // Sortie : 0
    fmt.Println(Samedi)  // Sortie : 6
}

Le code ci-dessus déclare une énumération pour les jours de la semaine, où iota s'initialise à 0 dans le bloc const et s'incrémente de 1 pour chaque déclaration ultérieure.

5.3 Portée des Constantes

La portée des constantes est similaire à celle des variables. Si une constante est définie à l'intérieur d'une fonction, sa portée est limitée à cette fonction. Si une constante est définie en dehors d'une fonction (au niveau global), sa portée est l'ensemble du package, et si la première lettre est en majuscule, elle peut être accessible dans d'autres packages.

La gestion de la portée des constantes contribue à réduire la pollution de l'espace global et améliore la maintenabilité et la lisibilité du programme.

const ConstGlobale = "Ceci est une constante globale"

func main() {
    const ConstLocale = "Ceci est une constante locale"
    fmt.Println(ConstGlobale)  // C'est valide
    fmt.Println(ConstLocale)   // C'est valide
}

func autreFonction() {
    // fmt.Println(ConstLocale) // Cela provoquera une erreur de compilation : ConstLocale n'est pas visible dans cette fonction
    fmt.Println(ConstGlobale)  // C'est valide
}

Dans cet exemple, ConstLocale ne peut être accessible qu'à l'intérieur de la fonction main, tandis que ConstGlobale peut être accessible dans l'ensemble du package.