Variables et types

Déclarer des variables

En Go, il y a deux façons de déclarer une variable :

package main

import "fmt"

func main() {
    // Déclaration longue avec var
    var nom string = "Alice"
    var age int = 30

    // Déclaration courte avec := (la plus utilisée)
    ville := "Paris"
    score := 42.5

    fmt.Println(nom, age, ville, score)
}

La différence ? := est un raccourci qui laisse Go déduire le type automatiquement. Vous l'utiliserez 90 % du temps. var est utile quand vous voulez déclarer une variable sans l'initialiser ou au niveau du package (là où := n'est pas autorisé).

Attention : Go est strict. Si vous déclarez une variable sans l'utiliser, le compilateur refuse de compiler. Zéro gaspillage. Lancez le code ci-dessus et changez une valeur pour voir.

Les types de base

Go est un langage à typage statique : chaque variable a un type fixé à la compilation. Voici les types essentiels :

nom := "Bonjour"      // string : chaîne de caractères
age := 25              // int : nombre entier
prix := 19.99          // float64 : nombre décimal
actif := true          // bool : vrai ou faux

Contrairement à Python ou JavaScript, vous ne pouvez pas mettre un nombre dans une variable string. Le compilateur vous arrête avant que le bug n'arrive en production.

Go a aussi des types numériques plus précis : int8, int16, int32, int64, float32, float64. Pour débuter, int et float64 suffisent largement.

Constantes

Une constante est une valeur qui ne change jamais. En Go, on utilise const :

const Pi = 3.14159
const AppName = "MonApp"
const MaxRetries = 3

// Pi = 3.0  // Erreur ! On ne peut pas modifier une constante

Les constantes sont évaluées à la compilation, pas à l'exécution. Elles sont plus rapides et plus sûres que les variables.

Pointeurs : & et *

Un pointeur est une variable qui contient l'adresse mémoire d'une autre variable. Deux opérateurs :

age := 25
ptr := &age    // & = "donne-moi l'adresse de age"
fmt.Println(ptr)   // 0xc0000b4008 (une adresse mémoire)
fmt.Println(*ptr)  // 25 : * = "donne-moi la valeur à cette adresse"

*ptr = 30          // Modifier la valeur via le pointeur
fmt.Println(age)   // 30 : age a changé !

Pourquoi les pointeurs ? Quand vous passez une variable à une fonction, Go en fait une copie. Avec un pointeur, la fonction peut modifier la variable originale. C'est essentiel pour l'efficacité.

Structs : créer vos propres types

Un struct regroupe plusieurs champs en un seul type. C'est l'équivalent d'un objet en JavaScript ou d'une classe en Python :

type Person struct {
    Name string
    Age  int
    City string
}

func main() {
    alice := Person{
        Name: "Alice",
        Age:  30,
        City: "Lyon",
    }
    fmt.Println(alice.Name) // Alice
    fmt.Println(alice.Age)  // 30
}

Les structs sont la base de la programmation en Go. Pas de classes, pas d'héritage : juste des structs et des fonctions. Simple et efficace.

À vous d'essayer :

package main

import "fmt"

type Person struct {
    Name string
    Age  int
    City string
}

func main() {
    ville := "Paris"
    score := 42.5
    alice := Person{Name: "Alice", Age: 30, City: "Lyon"}

    fmt.Println(ville, score)
    fmt.Println(alice.Name, alice.Age, alice.City)
}