Variables, constantes et déclarations

Variables : les boîtes pour stocker vos données

Imaginez les variables comme des boîtes étiquetées dans lesquelles vous pouvez ranger des informations (des données). Chaque boîte (variable) a un nom (l'étiquette) pour que vous puissiez la retrouver et un type qui indique quel genre de choses vous pouvez mettre dedans (nombres entiers, texte, etc.). En programmation, les variables servent à stocker temporairement des valeurs que votre programme va utiliser et manipuler.

En go, vous devez déclarer une variable avant de pouvoir l'utiliser. Déclarer une variable, c'est comme dire à go : "Hé go, j'ai besoin d'une nouvelle boîte, je vais l'appeler [nom de la variable] et elle servira à ranger des [type de données]". Une fois déclarée, vous pouvez affecter une valeur à la variable (mettre quelque chose dans la boîte) et récupérer la valeur (regarder ce qu'il y a dans la boîte) pour l'utiliser dans votre programme.

Go offre plusieurs façons de déclarer des variables, avec des syntaxes légèrement différentes. Nous allons explorer les deux principales méthodes : la déclaration avec le mot-clé var et la déclaration courte avec := (opérateur "court"). Comprendre ces différentes manières de déclarer des variables est essentiel pour écrire du code go clair et efficace, et pour pouvoir stocker et manipuler des données dans vos programmes.

Pourquoi est-ce important de comprendre les variables ? Les variables sont absolument fondamentales en programmation. Sans variables, vous ne pourriez pas mémoriser des informations, faire des calculs dynamiques, ou interagir avec l'utilisateur. Elles sont les briques de base de tout programme un peu complexe.

Constantes : les valeurs immuables

Les constantes sont similaires aux variables, mais avec une différence fondamentale : leur valeur ne peut pas être modifiée une fois qu'elle a été définie. Une constante représente une valeur fixe qui reste inchangée pendant toute l'exécution du programme. Les constantes sont utiles pour représenter des valeurs qui ne doivent pas varier, comme des constantes mathématiques (Pi), des configurations, des messages d'erreur fixes, etc. Imaginez des constantes comme des étiquettes permanentes sur vos boîtes, indiquant un contenu qui ne changera jamais.

En go, vous déclarez une constante en utilisant le mot-clé const suivi du nom de la constante, du type (optionnel, go peut inférer le type) et du signe égal = suivi de la valeur. La syntaxe générale est : const NomDeConstante [typeDeDonnée] = valeur (le type entre crochets est optionnel).

Exemples de déclaration de constantes :

const Pi float64 = 3.14159     // Déclare une constante 'Pi' de type float64
const MessageBienvenue string = "Bonjour !" // Déclare une constante 'MessageBienvenue' de type string
const NombreMax int = 100         // Déclare une constante 'NombreMax' de type int
const EstActif = true            // Déclare une constante 'EstActif' (go infère le type bool)

Points importants sur les constantes :

• Valeur immuable : Une fois définie, vous ne pouvez plus changer la valeur d'une constante. Tenter de modifier une constante provoquera une erreur de compilation. C'est une garantie que la valeur restera fixe.
• Déclaration obligatoire avec initialisation : Vous devez toujours initialiser une constante lors de sa déclaration. Vous ne pouvez pas déclarer une constante sans lui donner de valeur. Une constante doit avoir une valeur dès sa création.
• Type optionnel : Vous pouvez omettre le type lors de la déclaration d'une constante, go inférera le type à partir de la valeur (comme pour la déclaration courte de variables avec :=).
• Noms en `PascalCase` (par convention) : Par convention, les noms de constantes en go sont souvent écrits en PascalCase (majuscule au début de chaque mot, ex: Pi, MessageBienvenue, NombreMax). C'est une convention de style pour les distinguer visuellement des variables.
• Visibilité (exportée/non exportée) : Les mêmes règles de visibilité que pour les variables s'appliquent aux constantes : majuscule en début de nom pour les constantes exportées, minuscule pour les constantes non exportées.

Les constantes améliorent la lisibilité et la maintenabilité du code en donnant des noms significatifs à des valeurs fixes et en garantissant que ces valeurs ne seront pas modifiées accidentellement dans le programme. Utiliser des constantes rend votre code plus robuste et plus facile à comprendre, car vous savez que certaines valeurs ne changeront jamais.

Watch Out! Essayer de modifier la valeur d'une constante après sa déclaration provoquera une erreur de compilation ! Les constantes sont faites pour rester... constantes.

Déclarations multiples : déclarer plusieurs variables ou constantes en même temps

Go permet de déclarer plusieurs variables ou constantes en même temps en utilisant une syntaxe groupée avec des parenthèses () après les mots-clés var ou const. Cela peut rendre le code plus concis et plus organisé, surtout lorsqu'il s'agit de déclarer plusieurs variables ou constantes du même type ou liées entre elles. C'est une façon d'écrire du code plus propre et plus regroupé quand vous avez plusieurs déclarations à faire.

Exemples de déclarations multiples :

Déclarations multiples de variables avec `var` :

var (
    nom  string = "Charlie" // Variable 'nom' de type string
    age  int    = 42       // Variable 'age' de type int
    ville string         // Variable 'ville' de type string (valeur zéro par défaut : "")
)

Déclarations multiples de constantes avec `const` :

const (
    TauxTVA float64 = 0.20  // Constante 'TauxTVA' de type float64
    NbJoursSemaine int   = 7     // Constante 'NbJoursSemaine' de type int
    CouleurDefaut  string = "gris" // Constante 'CouleurDefaut' de type string
)

Dans ces exemples, les déclarations multiples sont regroupées entre parenthèses après var ou const. Chaque déclaration à l'intérieur des parenthèses est séparée par un saut de ligne. Cette syntaxe est particulièrement utile pour organiser les déclarations de variables ou de constantes apparentées et améliorer la lisibilité du code, surtout quand vous avez beaucoup de variables ou de constantes à déclarer au même endroit.

Exercices pratiques : variables, constantes et déclarations

Exercice 1 : Déclarations de variables

• Déclarez une variable nommée prenom de type string et initialisez-la avec votre prénom en utilisant var.
• Déclarez une variable nommée taille de type float64 et initialisez-la avec votre taille en mètres en utilisant la déclaration courte :=.
• Déclarez une variable nommée estMajeur de type bool sans l'initialiser explicitement. Question : Quelle sera sa valeur par défaut ?
• Affichez les valeurs de ces trois variables dans le terminal en utilisant fmt.Println.

Exercice 2 : Calcul avec des variables

• Imaginez un programme qui calcule le prix total d'un produit en fonction de la quantité commandée.
• Déclarez deux variables entières nombreProduits et prixUnitaire et initialisez-les avec des valeurs de votre choix (par exemple, quantité de produits commandés et prix d'un seul produit).
• Déclarez une variable prixTotal et affectez-lui le produit de nombreProduits et prixUnitaire en utilisant :=.
• Affichez la phrase : "Le prix total pour [nombreProduits] produits à [prixUnitaire] euros l'unité est : [prixTotal] euros" en remplaçant les crochets par les valeurs des variables.

Exercice 3 : Utilisation de constantes

• Imaginez que vous développez un programme pour calculer le prix TTC d'articles, avec une TVA fixe.
• Déclarez une constante nommée TVA de type float64 et initialisez-la avec la valeur 0.20 (20%). Pourquoi utiliser une constante ici ? Parce que le taux de TVA est généralement fixe.
• Déclarez une variable prixHT de type float64 et initialisez-la avec un prix hors taxes de votre choix.
• Calculez le prix TTC (Toutes Taxes Comprises) en utilisant la constante TVA (prixTTC = prixHT * (1 + TVA)) et affectez le résultat à une variable prixTTC.
• Affichez le prix HT et le prix TTC dans le terminal avec des messages clairs.

Exercice 4 : Déclarations multiples

• Utilisez une déclaration multiple avec var pour déclarer trois variables entières a, b et c sans les initialiser.
• Utilisez une déclaration multiple avec const pour déclarer deux constantes NomApplication (string) et VersionApplication (string) et initialisez-les avec des valeurs appropriées. Pourquoi utiliser des constantes pour le nom et la version de l'application ? Parce que ces informations sont généralement fixes pour une version donnée de l'application.
• Affichez les valeurs de toutes ces variables et constantes.

En résumé : variables, constantes et déclarations - les fondations

Félicitations ! Vous avez maintenant exploré les bases des variables, des constantes et des déclarations en Go. Vous savez comment :

• Déclarer des variables avec var et la déclaration courte :=.
• Initialiser des variables et comprendre les valeurs zéro.
• Utiliser des constantes pour les valeurs immuables.
• Choisir de bons noms pour vos variables et constantes.
• Déclarer plusieurs variables et constantes en même temps.

Ces concepts sont fondamentaux pour tout programme Go. Maîtriser les variables, les constantes et les déclarations, c'est comme apprendre l'alphabet et la grammaire d'une langue : c'est la base pour pouvoir écrire des phrases et des histoires plus complexes (vos futurs programmes Go!). Continuez à pratiquer avec les exercices et à explorer les chapitres suivants pour approfondir vos connaissances en Go !