If...Else en Rust

if permet à votre programme de prendre des décisions : exécuter un bloc de code ou un autre, selon une condition.

Un if simple

fn main() {
    let age = 20;

    if age >= 18 {
        println!("Vous pouvez voter");
    }
}

▶ Essayez par vous-même

Deux choses à remarquer, car elles surprennent souvent les gens qui viennent d’autres langages :

• Pas de parenthèses autour de la condition : if age >= 18, et non if (age >= 18).
• La condition doit être un vrai bool. if age (un nombre) ne compile pas : il faut écrire if age != 0 ou quelque chose de similaire.

if / else

fn main() {
    let age = 15;

    if age >= 18 {
        println!("Vous pouvez voter");
    } else {
        println!("Pas encore assez âgé");
    }
}

▶ Essayez par vous-même

else if pour plus de branches

fn main() {
    let score = 72;

    if score >= 90 {
        println!("Note : A");
    } else if score >= 75 {
        println!("Note : B");
    } else if score >= 60 {
        println!("Note : C");
    } else {
        println!("Note : F");
    }
}

▶ Essayez par vous-même

Rust teste chaque condition de haut en bas et exécute la première qui est vraie, exactement comme vous vous y attendez.

Utiliser if comme expression

Voici une chose que Rust sait faire et que beaucoup de langages ne savent pas : if peut produire une valeur. Vous pouvez donc l’utiliser à droite d’un let :

fn main() {
    let age = 20;
    let status = if age >= 18 { "majeur" } else { "mineur" };

    println!("{status}");
}

▶ Essayez par vous-même

Cela fonctionne comme le retour d’une valeur depuis une fonction : pas de point-virgule après la valeur dans chaque branche. Une seule exigence : les deux branches doivent produire le même type (ici, ce sont deux &str).

Attention

Si vous oubliez la branche else en utilisant if comme expression, Rust refuse de compiler : il ne sait pas quelle valeur utiliser quand la condition est fausse. Un if qui sert seulement à faire une action (comme afficher du texte) n’a pas besoin de else ; un if utilisé comme expression, si.

Combiner des conditions au lieu de les imbriquer

Vous pouvez placer un if à l’intérieur d’un autre if. Ça fonctionne, mais à deux ou trois niveaux de profondeur, cela devient difficile à lire. Souvent, vous pouvez plutôt relier les conditions avec les opérateurs logiques && (et) et || (ou) :

fn main() {
    let temperature = 22;
    let is_raining = false;

    // Imbriqué : ça marche, mais le code dérive vers la droite
    if temperature > 15 {
        if !is_raining {
            println!("Imbriqué : allez vous promener");
        }
    }

    // Le même test en une seule condition
    if temperature > 15 && !is_raining {
        println!("Combiné : allez vous promener");
    }

    // || est vrai si l'un des deux côtés est vrai
    if temperature < 0 || temperature > 35 {
        println!("Restez à l'intérieur");
    } else {
        println!("Il fait beau");
    }
}

Sortie :

Imbriqué : allez vous promener
Combiné : allez vous promener
Il fait beau

▶ Essayez par vous-même

L’imbrication reste utile quand le bloc intérieur fait quelque chose en plus, ou quand il a son propre else. Mais quand le if extérieur ne sert qu’à protéger le if intérieur, && dit la même chose plus simplement. Pour vérifier qu’un nombre est dans un intervalle, écrivez temperature >= 15 && temperature <= 25. Rust n’accepte pas 15 <= temperature <= 25.

Exercices

1. Pair ou impair

Stockez un nombre n = 7. Utilisez if comme expression pour donner à une variable kind la valeur "pair" ou "impair", puis affichez 7 est impair. Indice : un nombre est pair quand n % 2 == 0.

Voir la solution

fn main() {
    let n = 7;
    let kind = if n % 2 == 0 { "pair" } else { "impair" };
    println!("{n} est {kind}");
}

Sortie :

7 est impair

▶ Essayez par vous-même

2. Prix des billets

Un cinéma fait payer 5 euros aux enfants de moins de 12 ans, 7 aux personnes de 65 ans ou plus, et 12 à tous les autres. Stockez un age de 70, calculez le price avec une seule expression if / else if / else, et affichez Billet : 7 €. Indice : chaque branche doit renvoyer un nombre, et le if complet se termine par un point-virgule après la dernière }.

Voir la solution

fn main() {
    let age = 70;

    let price = if age < 12 {
        5
    } else if age >= 65 {
        7
    } else {
        12
    };

    println!("Billet : {price} €");
}

Sortie :

Billet : 7 €

▶ Essayez par vous-même

Récapitulatif

• if condition { ... } : pas besoin de parenthèses ; la condition doit être un bool.
• Enchaînez d’autres tests avec else if, et prévoyez un cas par défaut avec else.
• Reliez les conditions avec && et || au lieu d’imbriquer un if dans un if.
• if peut servir d’expression pour produire une valeur : les deux branches doivent avoir le même type, et il faut un else.

Petit quiz

Petit quiz

1. Laquelle de ces règles s'applique à la condition d'un if en Rust ?

Elle doit être entourée de parenthèses Elle doit être un vrai bool Elle doit être un entier

2. Quand on utilise if comme expression avec let, qu'exige-t-on des deux branches ?

Elles doivent toutes deux afficher quelque chose Elles doivent tenir chacune sur une ligne Elles doivent produire le même type

Score : 0 / 2

Pour aller plus loin

• if Expressions — The Rust Book (en anglais) : la présentation officielle de if, else if et de l’utilisation de if dans un let.
• if/else — Rust by Example (en anglais) : un exemple exécutable où les branches produisent une valeur.
• If expressions — The Rust Reference (en anglais) : les règles exactes, quand vous voudrez tous les détails.
• Rust sur Exercism (en anglais) : des exercices gratuits avec du mentorat ; les premiers s’appuient beaucoup sur if et else.