Types de base (int, float, bool, string)

Introduction aux types de données : la classification de l'information

En programmation, les types de données, c'est comme donner des étiquettes à vos informations. Imaginez que vous triez des jouets : vous mettez les voitures ensemble, les poupées ensemble, les blocs de construction ensemble. Les types de données font la même chose pour votre programme : ils disent à go quel type d'information vous utilisez (nombres, texte, vrai/faux...).

Pourquoi est-ce important ? Parce que cela permet à go de comprendre comment manipuler ces informations. Vous pouvez additionner des nombres, mais vous ne pouvez pas additionner du texte ! Les types de données aident go à s'assurer que vous faites les bonnes opérations avec les bonnes informations et à éviter des erreurs dans votre programme. C'est comme si go vérifiait que vous utilisez les bons outils pour chaque tâche.

Go est un langage qui vérifie très attentivement les types de données, on dit qu'il a un typage statique et fort. Pour vous, débutant, ça veut dire que go est un peu strict, mais c'est une bonne chose ! Go va vérifier que vous utilisez les types correctement avant même que votre programme ne s'exécute. Si vous essayez de mélanger des types incompatibles (comme additionner du texte et un nombre sans le dire explicitement à go comment faire), go vous le signalera comme une erreur.

Dans ce chapitre, nous allons découvrir les 4 types de données de base les plus importants en go :

• int (entiers) : Pour les nombres sans virgule (..., -2, -1, 0, 1, 2, ...)
• float64 (flottants) : Pour les nombres avec virgule (..., -3.14, 0.0, 2.71, ...)
• bool (booléens) : Pour les valeurs vrai ou faux (true ou false)
• string (chaînes de caractères) : Pour le texte ("Bonjour", "Go", "123", ...)

Ces types sont les fondations de tous vos programmes go. Bien les comprendre, c'est comme apprendre les bases de la grammaire avant d'écrire un roman ! C'est essentiel pour construire des programmes solides et qui fonctionnent bien.

Les nombres entiers (`int`) : représenter les nombres sans virgule

Le type int sert à stocker des nombres entiers, c'est-à-dire des nombres ronds, sans partie après la virgule. Pensez à l'âge, au nombre d'objets, aux scores... Ce sont tous des entiers. Exemples : -5, 0, 123, 10000.

En go, int est le type d'entier le plus courant. Sa taille dépend de votre ordinateur (généralement 64 bits sur les ordinateurs modernes, ce qui permet de stocker de très grands nombres entiers).

Opérations possibles avec les entiers : Vous pouvez faire des calculs classiques :

• Addition : + (ex: 5 + 3)
• Soustraction : - (ex: 10 - 2)
• Multiplication : * (ex: 4 * 6)
• Division entière : / (ex: 15 / 4 donne 3 car on garde seulement la partie entière)
• Reste de la division (modulo) : % (ex: 15 % 4 donne 3 car le reste de 15 divisé par 4 est 3)

Vous pouvez aussi comparer des entiers : == (égal), != (différent), > (plus grand que), < (plus petit que), >= (plus grand ou égal), <= (plus petit ou égal). Ces comparaisons donnent un résultat de type bool (vrai ou faux).

Si vous créez une variable int sans lui donner de valeur au départ, go lui donne automatiquement la valeur 0.

Attention à la division entière ! Quand vous divisez deux entiers avec /, go arrondit toujours vers le bas (tronque) le résultat. Si vous voulez une division avec des décimales, il faut utiliser les types flottants (float64).

Exemple d'utilisation du type `int` : Calculer l'âge dans 10 ans.

package main

import "fmt"

func main() {
    ageActuel := 30       // Je déclare une variable 'ageActuel' et je lui donne la valeur 30 (entier)
    ageDansDixAns := ageActuel + 10 // Je calcule l'âge dans 10 ans en ajoutant 10 à 'ageActuel'
    fmt.Println("Age actuel :", ageActuel) // J'affiche l'âge actuel
    fmt.Println("Age dans 10 ans :", ageDansDixAns) // J'affiche l'âge dans 10 ans
}

Les nombres flottants (`float64`) : représenter les nombres à virgule

Le type float64 sert à stocker des **nombres avec une partie décimale**, c'est-à-dire des nombres à virgule. Pensez aux prix, aux tailles, aux températures... Exemples : -2.5, 0.0, 3.14159, 1.618.

En go, on utilise principalement float64 (64 bits) pour les nombres flottants. Il existe aussi float32 (32 bits), mais float64 est plus précis et est souvent le meilleur choix par défaut. Imaginez mesurer avec une règle précise au millimètre (float64) ou une règle moins précise au centimètre (float32). Pour la plupart des choses, la règle au millimètre est préférable.

Opérations possibles avec les flottants : Presque les mêmes qu'avec les entiers :

• Addition : +
• Soustraction : -
• Multiplication : *
• Division : / (cette fois, la division donne un résultat avec décimales)

Vous pouvez aussi comparer les flottants avec les mêmes opérateurs que pour les entiers (==, !=, >, <, >=, <=).

Si vous déclarez une variable float64 sans valeur, go lui donne 0.0 par défaut.

Attention aux comparaisons de flottants ! Les ordinateurs ne stockent pas toujours les nombres flottants de manière parfaitement exacte. Il peut y avoir de petites erreurs d'arrondi. Donc, comparer directement deux flottants avec == pour vérifier s'ils sont *exactement* égaux peut parfois donner des résultats surprenants. En général, il vaut mieux vérifier si la différence entre deux flottants est très petite plutôt que de tester l'égalité stricte (mais pour l'instant, pour simplifier, on peut utiliser == pour les exemples simples).

Exemple d'utilisation du type `float64` : Calculer la circonférence d'un cercle.

package main

import (
    "fmt"
    "math" // J'importe le package 'math' pour utiliser des fonctions mathématiques comme Pi
)

func main() {
    rayon := 5.0          // Je déclare le rayon du cercle (nombre à virgule)
    pi := math.Pi         // 'math.Pi' est la constante Pi (3.14159...) du package 'math'
    circonference := 2 * pi * rayon // Je calcule la circonférence avec la formule
    fmt.Println("Rayon du cercle :", rayon)
    fmt.Println("Circonférence du cercle :", circonference)
}

Les booléens (`bool`) et les chaînes de caractères (`string`) : logique et texte

Le type bool représente **vrai ou faux**, c'est tout ! Il n'y a que deux valeurs possibles : true (vrai) et false (faux). On utilise les booléens pour représenter des **conditions** (est-ce que...?), des **choix** (oui ou non?), des **états** (activé ou désactivé?).

Opérations logiques avec les booléens :

• ET logique : && (vrai SEULEMENT si les deux côtés sont vrais)
• OU logique : || (vrai si au moins UN des côtés est vrai)
• NON logique : ! (inverse la valeur : !true donne false, !false donne true)

Vous pouvez aussi comparer des booléens avec == et !=.

Si vous déclarez une variable bool sans valeur, elle est false par défaut.

Le type string sert à stocker du **texte**, des **chaînes de caractères**. C'est tout ce que vous écrivez entre guillemets doubles : "Bonjour !", "Go est génial", "123 c'est aussi une chaîne".

Opérations sur les chaînes :

• Concaténation (mettre ensemble) : + (ex: "Hello" + " " + "World" donne "Hello World")
• Comparaison : ==, !=, <, >, etc. (compare l'ordre alphabétique)
• Obtenir la longueur (nombre de caractères) : len(votreString)

Go a plein d'autres fonctions pour manipuler les chaînes dans le package strings (pour chercher du texte, remplacer, couper, etc.).

Si vous déclarez une variable string sans valeur, elle est vide par défaut : "".

Exemple d'utilisation des types `bool` et `string` : Vérifier si un nombre est pair et afficher un message.

package main

import "fmt"

func main() {
    nombre := 7
    estPair := nombre%2 == 0 // Je vérifie si le reste de la division par 2 est 0 (donc si c'est pair), le résultat est 'true' ou 'false' (booléen)
    message := "Le nombre est impair" // Message par défaut (chaîne de caractères)
    if estPair { // Si 'estPair' est vrai (donc si le nombre est pair)
        message = "Le nombre est pair" // Je change le message
    }
    fmt.Println(message) // J'affiche le message (qui sera "Le nombre est pair" ou "Le nombre est impair")
    fmt.Println("Est pair ?", estPair) // J'affiche la valeur de 'estPair' (true ou false)
}

En résumé : types de base - le socle de vos données

Félicitations ! Vous avez maintenant exploré les 4 types de données de base essentiels en Go : int, float64, bool et string. Vous avez découvert qu'ils sont :

• int (entiers) : pour représenter les nombres ronds, sans virgule.
• float64 (flottants) : pour les nombres avec une partie décimale, les nombres à virgule.
• bool (booléens) : pour exprimer la logique, avec les valeurs true (vrai) et false (faux).
• string (chaînes de caractères) : pour manipuler le texte, les mots, les phrases.

Ces types de base sont les briques fondamentales de tous vos futurs programmes Go. Comprendre comment les utiliser et quand les choisir est absolument essentiel. C'est comme apprendre à distinguer les différents types d'ingrédients en cuisine : chaque type a son rôle et ses propriétés.

Maintenant, vous êtes prêt à aller plus loin et à explorer comment combiner ces types de base avec les opérateurs et les expressions pour créer des programmes Go de plus en plus sophistiqués. Continuez votre apprentissage, pratiquez les exercices, et vous progresserez rapidement dans votre maîtrise du langage Go !