Déclarer des variables
En Go, il y a deux façons de déclarer une variable :
// 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.5La 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.
Attention : Go est strict. Si vous déclarez une variable sans l'utiliser, le compilateur refuse de compiler. Zéro gaspillage.
Sortie attendue :
Alice 30 Paris 42.5Les 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 fauxContrairement à 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 constanteLes 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.
Sortie attendue :
Alice
30Declaring variables
In Go, there are two ways to declare a variable:
// Long declaration with var
var name string = "Alice"
var age int = 30
// Short declaration with := (most common)
city := "Paris"
score := 42.5The difference? := is a shortcut that lets Go infer the type automatically. You'll use it 90% of the time. var is useful when you want to declare a variable without initializing it or at the package level.
Warning: Go is strict. If you declare a variable without using it, the compiler refuses to compile. Zero waste.
Expected output:
Alice 30 Paris 42.5Basic types
Go is a statically typed language — every variable has a type fixed at compile time. Here are the essential types:
name := "Hello" // string — text
age := 25 // int — integer
price := 19.99 // float64 — decimal number
active := true // bool — true or falseUnlike Python or JavaScript, you can't put a number in a string variable. The compiler stops you before the bug reaches production.
Go also has more precise numeric types: int8, int16, int32, int64, float32, float64. For getting started, int and float64 are plenty.
Constants
A constant is a value that never changes. In Go, we use const:
const Pi = 3.14159
const AppName = "MyApp"
const MaxRetries = 3
// Pi = 3.0 // Error! You can't modify a constantConstants are evaluated at compile time, not at runtime. They are faster and safer than variables.
Pointers: & and *
A pointer is a variable that holds the memory address of another variable. Two operators:
age := 25
ptr := &age // & = "give me the address of age"
fmt.Println(ptr) // 0xc0000b4008 (a memory address)
fmt.Println(*ptr) // 25 — * = "give me the value at this address"
*ptr = 30 // Modify the value via the pointer
fmt.Println(age) // 30 — age changed!Why pointers? When you pass a variable to a function, Go makes a copy. With a pointer, the function can modify the original variable. This is essential for efficiency.
Structs: creating your own types
A struct groups multiple fields into a single type. It's the equivalent of an object in JavaScript or a class in 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
}Structs are the foundation of Go programming. No classes, no inheritance — just structs and functions. Simple and effective.
Expected output:
Alice
30Copiez les exemples ci-dessus et testez-les dans le Go Playground :
Copiez ce prompt dans Claude ou ChatGPT :
Crée un struct Go "Product" avec un nom, un prix et un stock. Écris une fonction qui applique une réduction de 10% sur le prix. Utilise un pointeur.