Variables (`var`, `:=`), types de base (int, float, string, bool)
Maîtrisez la déclaration de variables en Go avec `var` et `:=`. Explorez les types de données fondamentaux : entiers (int), flottants (float), chaînes (string) et booléens (bool).
Stocker l'information : Introduction aux variables en Go
Au coeur de tout langage de programmation se trouve la capacité de stocker et de manipuler des données. En Go, comme dans la plupart des langages, nous utilisons des variables pour cela. Une variable est essentiellement un nom symbolique associé à un emplacement en mémoire où une valeur peut être stockée et récupérée. Go étant un langage à typage statique, chaque variable a un type spécifique qui détermine la nature des données qu'elle peut contenir et les opérations qui peuvent être effectuées sur elle.
Go propose deux manières principales de déclarer des variables. La première utilise le mot-clé `var`. Cette forme est la plus explicite et peut être utilisée aussi bien à l'intérieur qu'à l'extérieur des fonctions (au niveau du paquet).
La syntaxe de base est `var nomVariable type`. Par exemple, `var age int` déclare une variable nommée `age` de type entier (`int`). Si vous ne fournissez pas de valeur initiale, la variable sera initialisée à la "valeur zéro" de son type (nous y reviendrons). Vous pouvez aussi initialiser la variable lors de sa déclaration : `var nomVariable type = valeur`. Exemple : `var message string = "Bonjour"`. Go permet également l'inférence de type avec `var` si une valeur initiale est fournie : `var nomVariable = valeur`. Dans ce cas, Go déduit le type de la variable à partir de la valeur assignée. Exemple : `var score = 100` (Go infère que `score` est de type `int`).
Il est aussi possible de déclarer plusieurs variables en une seule instruction `var` : `var x, y int` ou `var a, b = 10, "Go"`. Pour des déclarations multiples, on peut utiliser un bloc `var` :
var (
isActive bool
email string = "test@example.com"
index = 0
)La déclaration courte : L'opérateur `:=`
A l'intérieur des fonctions, Go offre une syntaxe plus concise pour déclarer et initialiser des variables : l'opérateur de déclaration courte `:=`. Cette syntaxe, `nomVariable := valeur`, combine la déclaration et l'initialisation en une seule étape, et le type de la variable est toujours inféré à partir de la valeur.
Par exemple, `compteur := 1` est équivalent à `var compteur = 1` (ou `var compteur int = 1`). C'est la manière la plus idiomatique et la plus courante de déclarer des variables locales en Go.
Important : L'opérateur `:=` ne peut être utilisé qu'à l'intérieur des blocs de fonction (ou d'autres blocs comme `if`, `for`, etc.). Vous ne pouvez pas l'utiliser pour déclarer des variables au niveau du paquet ; pour cela, vous devez utiliser `var`. Une autre caractéristique de `:=` est qu'il peut être utilisé dans une affectation où au moins une variable sur le côté gauche est nouvelle. Cela permet de réaffecter des variables existantes tout en en déclarant de nouvelles dans la même instruction, ce qui est souvent utile pour gérer les retours multiples de fonctions (notamment les erreurs).fichier, err := os.Open("monfichier.txt") // Déclare fichier et err
// ... plus tard ...
donnees, err := io.ReadAll(fichier) // Réaffecte err, déclare donnees
// (à condition que 'err' soit dans le même scope)Les nombres entiers : Le type `int` et ses variantes
Les nombres entiers sont des nombres sans partie décimale. Go propose plusieurs types pour représenter les entiers, signés (pouvant être négatifs) et non signés (uniquement positifs ou nuls). Le type le plus couramment utilisé est `int`. Sa taille (32 ou 64 bits) dépend de l'architecture de votre système. De même, `uint` est un entier non signé dont la taille dépend de l'architecture.
Go fournit également des types d'entiers de taille fixe, utiles lorsque vous avez besoin d'un contrôle précis sur la taille et la plage de valeurs (par exemple, pour l'interaction avec des systèmes externes, l'optimisation de la mémoire, ou pour garantir le même comportement sur différentes architectures) :
- Signés : `int8`, `int16`, `int32` (alias `rune`), `int64`
- Non signés : `uint8` (alias `byte`), `uint16`, `uint32`, `uint64`
La valeur zéro pour tous les types entiers est `0`. Voici quelques exemples :
var annee int = 2024
var temperature int8 = -5
compteur := 0 // Type inféré : int
var masque uint32 = 0xFFFFFFFF
var b byte = 'A' // byte est un alias pour uint8, stocke la valeur ASCII/UTF-8Les nombres décimaux : Types `float32` et `float64`
Pour représenter les nombres avec une partie décimale (nombres à virgule flottante), Go propose deux types conformes à la norme IEEE-754 : `float32` et `float64`. `float32` utilise 32 bits (simple précision) et `float64` utilise 64 bits (double précision).
En général, `float64` est le type flottant préféré car il offre une plus grande précision. Si vous écrivez un littéral flottant comme `3.14159` sans spécifier de type, Go l'interprétera par défaut comme `float64`. Utilisez `float32` uniquement si vous avez des contraintes spécifiques de mémoire ou de performance, ou pour l'interopérabilité avec des systèmes qui l'exigent.
La valeur zéro pour les types flottants est `0.0`. Exemples :
var pi float64 = 3.1415926535
prix := 99.99 // Type inféré : float64
var tolerance float32 = 0.001Vrai ou Faux : Le type `bool`
Le type booléen, `bool`, représente une valeur de vérité logique. Il ne peut avoir que deux valeurs possibles : `true` (vrai) ou `false` (faux). Les booléens sont fondamentaux pour la prise de décision dans le code, notamment dans les structures de contrôle comme `if` et `for`.
La valeur zéro pour le type `bool` est `false`. Exemples :
var estActif bool = true
var estFerme bool // Initialisé à false (valeur zéro)
isConnected := false
fmt.Println(5 > 3) // Affiche: true
fmt.Println(estActif == isConnected) // Affiche: falseTexte et caractères : Le type `string`
Le type `string` représente une séquence de bytes. En Go, les chaînes de caractères sont généralement utilisées pour contenir du texte encodé en UTF-8, ce qui leur permet de représenter un large éventail de caractères de différentes langues. Une caractéristique importante des strings en Go est qu'elles sont immutables : une fois qu'une chaîne est créée, son contenu ne peut plus être modifié. Les opérations qui semblent modifier une chaîne (comme la concaténation) créent en réalité une nouvelle chaîne.
Les chaînes peuvent être définies en utilisant des guillemets doubles `"..."` ou des backticks ``` `...` ```.
- Guillemets doubles (`"..."`) : Créent une chaîne interprétée. Les séquences d'échappement comme `` (nouvelle ligne), `` (tabulation), `\` (backslash), `"` (guillemet double) sont interprétées.
- Backticks (``` `...` ```) : Créent une chaîne brute (raw string literal). Aucune séquence d'échappement n'est interprétée, et la chaîne peut s'étendre sur plusieurs lignes, préservant les retours à la ligne et les espaces tels quels.
La valeur zéro pour le type `string` est la chaîne vide `""`. Exemples :
var nom string = "Alice"
message := "Bonjour, \"Bob\"!\nCeci est sur une nouvelle ligne."
cheminFichier := `C:\Utilisateurs\Documents`
requeteSQL := `SELECT nom
FROM utilisateurs
WHERE id = ?`
chaineVide := "" // Valeur zéro
salutation := "Salut " + nom // Concaténation
fmt.Println(salutation) // Affiche: Salut AliceComprendre ces types de base et savoir comment déclarer des variables avec `var` et `:=` sont des compétences fondamentales en Go. Elles constituent le socle sur lequel vous construirez des logiques plus complexes à l'aide des structures de contrôle et des fonctions que nous aborderons prochainement.