Masquage
Réaffectation des variables
Masquage est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que le masquage ?
Le masquage consiste à déclarer une nouvelle variable portant le même nom qu'une variable précédente. La nouvelle liaison « masque » l'ancienne.
Pour cela, vous répétez let avec le même nom.
fn main() {
let x = 5;
let x = x + 1;
let x = x * 2;
println!("x is {}", x);
}Le masquage n'est pas une mutation
Le masquage crée une variable entièrement nouvelle. Cela diffère de mut, qui réutilise la même variable.
Comme chaque let crée une nouvelle liaison, les valeurs peuvent même avoir des types différents.
fn main() {
let y = 10; // immutable
let y = y + 5; // new binding, also immutable
println!("y is {}", y);
}Changer de type avec le masquage
Le masquage permet notamment de réutiliser un nom tout en changeant son type.
Ici, une chaîne de caractères est analysée pour obtenir un nombre sous le même nom.
fn main() {
let spaces = " ";
let spaces = spaces.len();
println!("count is {}", spaces);
}Pourquoi mut ne peut pas changer de type
Avec mut, vous pouvez modifier la valeur, mais pas le type.
Ce code ne compilerait pas :
let mut spaces = " ";spaces = spaces.len();— erreur d'incompatibilité de types.
Le masquage évite ce problème, car il crée une nouvelle variable.
fn main() {
let mut count = 3;
count = 4; // ok, same type
println!("{}", count);
}Le masquage dans les portées internes
Une variable peut être masquée dans un bloc interne. Lorsque le bloc se termine, la liaison externe redevient visible.
fn main() {
let n = 1;
{
let n = n * 10;
println!("inner {}", n);
}
println!("outer {}", n);
}Transformer étape par étape
Le masquage vous permet de transformer une valeur en plusieurs étapes tout en conservant un nom clair.
fn main() {
let input = "42";
let input: i32 = input.trim().parse().unwrap();
let input = input * 2;
println!("result {}", input);
}Le masquage préserve l'immuabilité
Chaque liaison masquée reste immuable. Après une transformation, vous conservez la sécurité de l'immuabilité sans devoir inventer de nouveaux noms comme x2 ou x_temp.
fn main() {
let price = 100;
let price = price - 20; // discount applied
let price = price + 5; // shipping added
println!("final price {}", price);
}Masquage et logique différente
Vous pouvez calculer la nouvelle valeur comme vous le souhaitez, notamment en utilisant des appels de fonction ou des expressions.
fn main() {
let text = "hello";
let text = text.to_uppercase();
println!("{}", text);
}Éviter la confusion
Le masquage est pratique, mais en abuser peut rendre le code difficile à comprendre. Utilisez-le lorsque chaque étape est une transformation claire du même concept, et non simplement pour réutiliser des noms au hasard.
fn main() {
let raw = " Rust ";
let raw = raw.trim(); // clean version
println!("[{}]", raw);
}Masquage et réaffectation : résumé
Deux façons d'attribuer une nouvelle valeur à un nom :
- Masquage :
let x = ...;à nouveau — nouvelle variable, changement de type possible, reste immuable. - Réaffectation :
x = ...;avecmut— même variable, même type obligatoire.
fn main() {
let val = "7";
let val: i32 = val.parse().unwrap(); // shadow + type change
let mut val = val;
val += 1; // reassign, same type
println!("{}", val);
}Un exemple pratique
La lecture et la conversion de données utilisateur sont un cas classique de masquage : conservez le nom significatif age tandis que le type passe du texte au nombre.
fn main() {
let age = "25";
let age: u32 = age.parse().unwrap();
let age = age + 1; // next birthday
println!("next year you will be {}", age);
}Vérification rapide
Déterminez ce qui distingue le masquage de l'utilisation de mut.
Récapitulatif
Le masquage dans Rust :
- Répétez
letavec le même nom pour créer une nouvelle liaison. - La nouvelle liaison peut avoir un type différent.
- Chaque valeur masquée reste immuable.
- Il diffère de
mut, qui modifie la même variable et conserve son type.
fn main() {
let data = "100";
let data: i32 = data.parse().unwrap();
let data = data / 4;
println!("final {}", data);
}Questions Fréquemment Posées
La leçon « Masquage » est-elle gratuite ?
Oui — le texte complet de « Masquage » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Masquage » ?
Réaffectation des variables Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Masquage » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.