0Pricing
Learn Rust Coding · Leçon

Variables, mutabilité et masquage

Comprenez comment déclarer des variables, gérer leur mutabilité et utiliser le masquage pour redéfinir des variables avec souplesse.

Variables, mutabilité et masquage est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. 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 3 leçons au total.

Introduction aux variables Rust

Bienvenue ! Dans Rust, les variables sont essentielles pour stocker des données. Elles ressemblent à des boîtes étiquetées dans lesquelles vous conservez les informations dont votre programme a besoin.

Rust accorde une grande importance à la sécurité, et cela commence par la manière dont il gère les variables. Vous apprendrez à les déclarer, à contrôler leur possibilité de modification et même à les « redéfinir » de façon astucieuse.

Déclarer des variables avec `let`

Pour créer une variable en Rust, nous utilisons le mot-clé let. Celui-ci associe un nom à une valeur. Rust déduit souvent le type, vous n’avez donc pas toujours besoin de le préciser.

Essayez d’exécuter cet exemple simple :

fn main() {
  let apples = 5;
  println!("I have {} apples.", apples);
}

L’immuabilité par défaut de Rust

Un concept clé de Rust est que les variables sont immutables par défaut. Une fois qu’une valeur a été affectée à une variable, vous ne pouvez plus la modifier.

Cela peut sembler restrictif, mais cela aide à éviter les bogues et rend votre code plus sûr et plus facile à comprendre, notamment dans la programmation concurrente.

Rendre les variables modifiables avec `mut`

Si vous devez modifier la valeur d’une variable, vous pouvez explicitement la rendre modifiable en utilisant le mot-clé mut avant le nom de la variable.

Cela indique à Rust (et aux autres développeurs) que la valeur de cette variable est destinée à être modifiée.

fn main() {
  let mut score = 100;
  println!("Initial score: {}", score);

  score = 150; // We can change it now!
  println!("New score: {}", score);
}

Quand utiliser `mut`

Bien que mut soit puissant, il est recommandé de ne l’utiliser que lorsque c’est nécessaire. Privilégiez l’immuabilité par défaut.

  • Utilisez mut pour les compteurs, les variables d’état ou les valeurs qui doivent réellement être mises à jour.
  • Si une valeur ne change jamais après son affectation initiale, laissez-la immutable (sans mut).
  • Clarté : marquer explicitement une variable comme mut rend l’intention de votre code plus claire.

Définir des constantes avec `const`

Les constantes sont des types particuliers de variables immutables. Elles sont déclarées avec le mot-clé const plutôt qu’avec let, et leur type doit toujours être indiqué explicitement.

Les constantes peuvent uniquement recevoir des expressions constantes, et non le résultat d’un appel de fonction ou une valeur qui ne pourrait être calculée qu’à l’exécution.

fn main() {
  const MAX_USERS: u32 = 10_000; // Type annotation is required!
  println!("Max users allowed: {}", MAX_USERS);
}

Variables `let` ou constantes `const`

Voici les principales différences entre les variables let et les constantes const :

  • Possibilité de modification : les variables let sont immutables par défaut, mais peuvent être rendues modifiables avec mut. Les constantes const sont toujours immutables.
  • Déclaration : let utilise let. const utilise const.
  • Annotation de type : les variables let permettent souvent de déduire leur type. Le type des constantes const doit obligatoirement être indiqué.
  • Portée : les constantes const peuvent être déclarées dans n’importe quelle portée, y compris la portée globale.

Découvrir le masquage

Rust vous permet de déclarer une nouvelle variable portant le même nom qu’une variable précédente. C’est ce qu’on appelle le masquage.

La nouvelle variable « masque » l’ancienne : tout le code suivant verra la valeur de la nouvelle variable. L’ancienne variable existe toujours en mémoire, mais vous ne pouvez plus y accéder directement.

fn main() {
  let x = 5;
  println!("First x: {}", x); // Outputs 5

  let x = x + 1; // 'x' is shadowed by a new 'x'
  println!("Second x: {}", x); // Outputs 6

  { // Inner scope
    let x = x * 2; // 'x' is shadowed again
    println!("Inner x: {}", x); // Outputs 12
  }
  println!("Outer x: {}", x); // Outputs 6 (inner x is out of scope)
}

Utiliser le masquage pour convertir un type

Le masquage permet notamment de transformer la valeur d’une variable, voire son type, tout en conservant le même nom. C’est courant lorsque vous devez analyser une chaîne pour la convertir en nombre.

Au lieu de créer un nouveau nom de variable (par exemple, string_val puis num_val), vous pouvez réutiliser le même nom.

fn main() {
  let spaces = "   ";
  println!("Spaces string: '{}'", spaces);

  // Shadow 'spaces' with a new variable that holds its length
  let spaces = spaces.len();
  println!("Spaces count: {}", spaces);
}

Vérification rapide : variables et possibilité de modification

Examinez le code Rust suivant. Quelle sera la valeur finale de y affichée dans la console ?

Récapitulatif : variables, possibilité de modification et masquage

Excellent travail ! Vous avez appris les notions essentielles sur les variables en Rust :

  • Utilisez let pour déclarer des variables, qui sont immutables par défaut.
  • Ajoutez mut pour rendre une variable modifiable, ce qui permet de changer sa valeur.
  • Utilisez const pour les constantes, qui sont toujours immutables et nécessitent des annotations de type.
  • Le masquage permet de déclarer une nouvelle variable portant le même nom et de remplacer la précédente. Cette technique est utile pour les conversions de type.

Nous allons maintenant explorer les différents types de données primitifs de Rust !

Questions Fréquemment Posées

La leçon « Variables, mutabilité et masquage » est-elle gratuite ?

Oui — le texte complet de « Variables, mutabilité et 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 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Variables, mutabilité et masquage » ?

Comprenez comment déclarer des variables, gérer leur mutabilité et utiliser le masquage pour redéfinir des variables avec souplesse. 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 1 sur 3.

Combien de temps prend la leçon « Variables, mutabilité et 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.

Toutes les leçons de ce cours

  1. Variables, mutabilité et masquage
  2. Types de données primitifs et opérateurs
  3. Fonctions et flux de contrôle
← Retour à Learn Rust Coding