Learn Rust Coding · Leçon

Expressions et instructions

La dernière expression

Expressions et instructions est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 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.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Statements vs Expressions

Rust distinguishes two kinds of code:

Statements perform an action and return no value.
Expressions evaluate to a value.

This distinction shapes how functions return values.

fn main() {
    let x = 5;      // a let statement
    let y = x + 1;  // x + 1 is an expression
    println!("{}", y);
}

let Is a Statement

A let binding is a statement. It does not return a value, so you cannot write let a = (let b = 6);.

fn main() {
    let a = 6;
    // let c = (let d = 6); // error: let is not an expression
    println!("{}", a);
}

Expressions Evaluate to Values

Arithmetic, function calls, and literals are all expressions because they produce a value.

5
2 + 3
square(4)

fn main() {
    let v = 2 + 3 * 4;
    println!("{}", v);
}

Blocks Are Expressions

A block { ... } is itself an expression. Its value is the last expression inside, if it has no trailing semicolon.

fn main() {
    let y = {
        let x = 3;
        x + 1
    };
    println!("y is {}", y);
}

The Semicolon Matters

Adding a semicolon turns an expression into a statement, discarding its value.

x + 1 — expression, yields a value.
x + 1; — statement, yields ().

fn main() {
    let y = {
        let x = 3;
        x + 1   // no semicolon: this is the block's value
    };
    println!("{}", y);
}

The Last Expression Returns

In a function, the final expression with no semicolon becomes the return value. This is idiomatic Rust.

fn main() {
    println!("{}", five());
}

fn five() -> i32 {
    5
}

Semicolon Breaks Returns

If you accidentally add a semicolon to the last line, the function returns () instead of your value — a common beginner error.

fn main() {
    println!("{}", plus_one(10));
}

fn plus_one(n: i32) -> i32 {
    n + 1   // correct: no semicolon
}

if as an Expression

Because if is an expression, you can assign its result to a variable. Both branches must yield the same type.

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("number is {}", number);
}

loop as an Expression

A loop can return a value through break. The value after break becomes the loop's result.

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };
    println!("result {}", result);
}

match as an Expression

A match is also an expression. Each arm produces a value, and the matched arm's value is the result.

fn main() {
    let n = 2;
    let label = match n {
        1 => "one",
        2 => "two",
        _ => "many",
    };
    println!("{}", label);
}

Putting It Together

Treating blocks and control flow as expressions makes Rust concise: you compute and return in one fluid step.

fn main() {
    let score = 85;
    let grade = if score >= 90 { 'A' } else if score >= 80 { 'B' } else { 'C' };
    println!("grade {}", grade);
}

Quick Check

What does adding a semicolon do to an expression?

Recap

Expressions and statements in Rust:

Statements (like let) do work but return no value.
Expressions evaluate to a value.
Blocks, if, match, and loop are expressions.
The last expression without a semicolon is the return value.

fn main() {
    let x = { let a = 2; a * a };
    let y = if x > 3 { "big" } else { "small" };
    println!("{} {}", x, y);
}

Questions Fréquemment Posées

La leçon « Expressions et instructions » est-elle gratuite ?

Oui — le texte complet de « Expressions et instructions » 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 « Expressions et instructions » ?

La dernière expression 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 2 sur 4.

Combien de temps prend la leçon « Expressions et instructions » ?

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