Leçons du module (1/2)
Variables et mutabilité
En Rust, la gestion des variables et de la mémoire est guidée par deux principes fondamentaux : la sécurité et le contrôle. Pour cette raison, contrairement à de nombreux autres langages de programmation, les variables dans Rust sont immuables par défaut.
Cela signifie qu'une fois qu'une valeur a été assignée à une variable, celle-ci ne peut plus être modifiée. Si vous tentez de le faire, le compilateur générera une erreur.
Variables Immuables et Mot-Clé mut
Pour déclarer une variable, on utilise le mot-clé let :
let x = 5; // Immutabile di default
// x = 6; // ERRORE! Il compilatore si rifiuterà di compilare.
Si vous avez besoin de modifier la valeur d'une variable, vous devez la rendre explicitement mutable en utilisant le mot-clé mut juste après let :
let mut y = 10; // Mutabile
println!("Il valore di y e: {}", y);
y = 15; // Valido!
println!("Il valore modificato di y e: {}", y);
L'utilisation du préfixe mut indique clairement au compilateur et au lecteur du code que cette valeur changera au cours de l'exécution.
Shadowing (Masquage)
Rust autorise également le concept de shadowing (masquage), c'est-à-dire la redéclaration d'une variable avec le même nom en utilisant à nouveau le mot-clé let. La nouvelle variable "couvre" (ou masque) la précédente :
let x = 5;
let x = x + 1; // Shadowing: x ora vale 6
let x = x * 2; // Shadowing: x ora vale 12
Contrairement à mut, le shadowing vous permet de :
- Changer le type de données d'une variable tout en conservant le même nom.
- Maintenir l'immuabilité de la variable après les transformations.
let spaces = " "; // Tipo: &str (stringa)
let spaces = spaces.len(); // Tipo: usize (numero intero)
Utilité du Shadowing et Portées (Scopes)
Le shadowing ne se limite pas au même bloc ; il peut être utilisé à l'intérieur de blocs imbriqués ({}) pour écraser temporairement une valeur. Lorsque le bloc interne se termine, la variable d'origine redevient visible :
let x = 5;
{
let x = x * 2; // Shadowing valido solo all'interno del blocco
println!("Valore nel blocco interno: {}", x); // Stampa 10
}
println!("Valore nel blocco esterno: {}", x); // Stampa 5
Ce mécanisme est extrêmement sûr et efficace car il se produit entièrement au moment de la compilation, garantissant la sécurité des types sans aucun coût de performance à l'exécution.
À toi de jouer
Déclarez une variable mutable nommée x avec la valeur initiale 5. Ajoutez ensuite 10 à x et affichez-la à l'écran à l'aide de la macro println!.
Afficher l'indice
Déclarez la variable avec `let mut x = 5;`, puis incrémentez-la avec `x += 10;` (ou `x = x + 10;`) et enfin affichez-la avec `println!('{}', x);`.
Solution disponible après 3 tentatives
Déclarez une variable immuable y avec la valeur 10. Effectuez le shadowing de y en la déclarant à nouveau avec let pour multiplier sa valeur précédente par 2, et enfin affichez-la à l'aide de println!.
Afficher l'indice
Utilisez `let y = 10;`, puis effectuez le shadowing en la déclarant à nouveau avec `let y = y * 2;` et enfin utilisez `println!` pour l'afficher.
Solution disponible après 3 tentatives
Déclarez une variable immuable input contenant la valeur de type chaîne "42". Effectuez le shadowing de input en la déclarant comme un entier de type i32 en convertissant la valeur d'origine via input.parse::<i32>().unwrap(). Enfin, affichez-la à l'aide de la macro println!.
Afficher l'indice
Déclarez `let input = "42";`, puis effectuez le shadowing avec `let input: i32 = input.parse().unwrap();` et affichez-la avec `println!("{}", input);`.
Solution disponible après 3 tentatives