#3 Variables et types

Immuable par défaut

En Rust, les variables sont immuables par défaut. Cela signifie qu'une fois qu'on a assigné une valeur, on ne peut plus la modifier. C'est un choix de conception qui rend le code plus sûr.

let x = 5;
println!("x = {x}");

// x = 10; // Erreur ! x est immuable

Le mot-clé let déclare une variable. Sans autre indication, elle est immuable. Le compilateur vous arrêtera si vous essayez de la modifier.

Variables mutables (mut)

Pour autoriser la modification, ajoutez le mot-clé mutaprès let :

let mut x = 5;
println!("x = {x}");

x = 10; // OK, x est mutable
println!("x = {x}");

En Rust, la mutabilité est un choix explicite. Cela permet de savoir immédiatement en lisant le code quelles variables peuvent changer de valeur.

Constantes

Les constantes sont déclarées avec const et doivent toujours avoir un type annoté. Elles ne peuvent jamais être mutables et sont évaluées à la compilation.

const MAX_POINTS: u32 = 100_000;
println!("MAX_POINTS = {MAX_POINTS}");

Par convention, les constantes s'écrivent en MAJUSCULES_AVEC_UNDERSCORES. Notez l'utilisation de _ comme séparateur de milliers pour améliorer la lisibilité.

Types de base

Rust est un langage fortement typé. Voici les types primitifs les plus courants :

// Entiers
let entier: i32 = 42;        // entier signé 32 bits
let non_signe: u64 = 100;    // entier non signé 64 bits

// Flottants
let flottant: f64 = 3.14;    // flottant 64 bits

// Booléen
let actif: bool = true;

// Caractère (Unicode)
let lettre: char = 'R';

Rust peut souvent inférer le type automatiquement, mais vous pouvez toujours l'annoter explicitement avec la syntaxe let nom: Type = valeur;.

// Tuple : groupement de valeurs de types différents
let point: (f64, f64) = (3.0, 4.0);
let (x, y) = point; // Déstructuration

// Tableau : taille fixe, même type
let nombres: [i32; 3] = [1, 2, 3];
let premier = nombres[0]; // Accès par index

À vous de jouer

Essayez les commandes ci-dessous pour voir les variables en action :