Learn Rust Coding · Leçon

let et mutabilité

Liaisons et mutabilité

let et mutabilité est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 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.

Lier des valeurs avec let

En Rust, vous créez une variable avec le mot-clé let. Cela associe un nom à une valeur.

Par défaut, chaque liaison est immuable — une fois qu’une valeur lui est attribuée, vous ne pouvez plus la modifier.

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
}

Immuable par défaut

Rust rend volontairement les variables immuables. Cela évite les modifications accidentelles et facilite le raisonnement sur le code.

Essayer de réattribuer une liaison immuable provoque une erreur de compilation, et non un plantage à l’exécution.

let x = 5; puis x = 6; ne sera pas compilé.

fn main() {
    let x = 5;
    // x = 6; // this would cause a compile error
    println!("x stays {}", x);
}

Rendre les variables mutables

Lorsque vous devez modifier une valeur, ajoutez le mot-clé mut. Cela indique que la liaison est mutable.

Vous pouvez alors la réattribuer autant de fois que vous le souhaitez.

fn main() {
    let mut count = 0;
    count = count + 1;
    count += 1;
    println!("count is {}", count);
}

Inférence de type

Rust détermine généralement le type d’une variable à partir de sa valeur. C’est ce qu’on appelle l’inférence de type.

let x = 5; attribue automatiquement à x le type i32.

fn main() {
    let n = 42;      // inferred as i32
    let pi = 3.14;   // inferred as f64
    println!("{} and {}", n, pi);
}

Annotations de type

Vous pouvez aussi indiquer explicitement le type avec deux-points et un nom de type. C’est une annotation de type.

Les annotations sont utiles lorsque le compilateur ne peut pas inférer le type, ou pour améliorer la clarté.

fn main() {
    let age: u32 = 30;
    let price: f64 = 9.99;
    println!("age {} price {}", age, price);
}

Constantes

Une const est toujours immuable et doit posséder une annotation de type. Sa valeur doit être connue lors de la compilation.

Par convention, les constantes utilisent SCREAMING_SNAKE_CASE.

fn main() {
    const MAX_POINTS: u32 = 100_000;
    println!("Max is {}", MAX_POINTS);
}

const et let

Principales différences entre const et let :

const ne peut jamais être mut.
const nécessite une annotation de type.
const doit être une expression constante évaluée à la compilation.
Les valeurs de let peuvent être calculées à l’exécution.

fn main() {
    const SECONDS_PER_HOUR: u32 = 60 * 60;
    let hours = 3;
    println!("{} seconds", SECONDS_PER_HOUR * hours);
}

Modifier une valeur dans une boucle

Les variables mutables sont courantes dans les boucles, lorsqu’une valeur s’accumule au fil du temps.

Ici, nous additionnons des nombres à l’aide d’un accumulateur mut.

fn main() {
    let mut total = 0;
    for i in 1..=5 {
        total += i;
    }
    println!("Sum is {}", total);
}

Le caractère souligné pour les valeurs inutilisées

Si vous liez une valeur sans jamais l’utiliser, Rust vous avertit. Préfixez le nom par un caractère souligné pour faire disparaître l’avertissement.

let _unused = 10; indique au compilateur que cette situation est intentionnelle.

fn main() {
    let _temp = 99;
    let used = 1;
    println!("{}", used);
}

Liaisons multiples

Vous pouvez déclarer plusieurs variables sur des lignes distinctes, chacune avec son propre let.

Chaque liaison est indépendante et immuable, sauf si elle est marquée mut.

fn main() {
    let name = "Rust";
    let year = 2010;
    let mut version = 1;
    version += 1;
    println!("{} born {} v{}", name, year, version);
}

Pourquoi l’immuabilité est utile

L’immuabilité est une fonctionnalité de sécurité. Lorsque le compilateur sait qu’une valeur ne peut pas changer, il peut fournir de meilleures garanties et empêcher toute une catégorie de bogues.

N’utilisez mut que lorsque vous avez réellement besoin de modifier une valeur.

fn main() {
    let config = "production";
    // config is guaranteed not to change
    println!("Running in {}", config);
}

Vérification rapide

Quel mot-clé permet de modifier une variable Rust ?

Récapitulatif

Vous avez appris les bases des liaisons en Rust :

let associe un nom à une valeur, immuable par défaut.
mut rend une liaison mutable.
Rust infère les types, mais vous pouvez ajouter des annotations avec :.
const est évaluée à la compilation, toujours immuable et nécessite un type.

fn main() {
    let mut score: u32 = 0;
    const BONUS: u32 = 10;
    score += BONUS;
    println!("Final score: {}", score);
}

Questions Fréquemment Posées

La leçon « let et mutabilité » est-elle gratuite ?

Oui — le texte complet de « let et mutabilité » 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 « let et mutabilité » ?

Liaisons et mutabilité 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 4.

Combien de temps prend la leçon « let et mutabilité » ?

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

← Retour à Learn Rust Coding