Les booléens en Rust

Un booléen est le type le plus simple qui existe : il ne peut valoir que true (vrai) ou false (faux). En Rust, il s’appelle bool, et vous l’utiliserez partout où votre code doit prendre une décision.

Déclarer un booléen

fn main() {
    let is_active = true;
    let has_error: bool = false;
    println!("actif : {is_active}, erreur : {has_error}");
}

▶ Essayez par vous-même

Rust devine presque toujours tout seul qu’il s’agit d’un bool à partir de true ou false : vous aurez rarement besoin d’écrire le type.

Les booléens viennent souvent des comparaisons

Dans du vrai code, on écrit rarement true ou false à la main. Le plus souvent, ils sont le résultat d’une comparaison :

fn main() {
    let age = 20;
    let can_vote = age >= 18;
    println!("Peut voter : {can_vote}");
}

Sortie :

Peut voter : true

▶ Essayez par vous-même

Utiliser les booléens dans des conditions

Le rôle principal d’un bool, c’est de décider quelle branche d’un if s’exécute :

fn main() {
    let is_raining = true;

    if is_raining {
        println!("Prenez un parapluie");
    } else {
        println!("Laissez-le à la maison");
    }
}

Nous verrons if en détail sur la page If…Else. Ici, c’est juste un avant-goût de l’utilité des booléens.

Note

Contrairement à d’autres langages, Rust ne considère pas 0, une chaîne vide ou null comme « faux ». Une condition doit être un vrai bool, rien d’autre n’est accepté. Cela élimine toute une famille de bugs dès la compilation.

Combiner des booléens et le court-circuit

Vous avez vu && (et), || (ou) et ! (non) sur la page Les opérateurs. Il reste une chose à savoir : ils s’arrêtent dès que la réponse est connue. C’est ce qu’on appelle l’évaluation en court-circuit.

• Avec a && b, si a vaut false, le tout vaut forcément false : Rust ne regarde jamais b.
• Avec a || b, si a vaut true, le tout vaut forcément true : Rust ne regarde jamais b.

Ce n’est pas qu’une question de rapidité. Le côté gauche peut ainsi protéger le côté droit :

fn main() {
    let count = 0;
    let total = 50;

    // count vaut 0, donc Rust s'arrête après `count != 0` et ne fait jamais la division.
    let big_average = count != 0 && total / count > 10;
    println!("grande moyenne : {big_average}");

    let is_weekend = true;
    let has_homework = true;
    // is_weekend vaut true, donc `!has_homework` n'est jamais évalué.
    let can_relax = is_weekend || !has_homework;
    println!("peut se détendre : {can_relax}");
}

Sortie :

grande moyenne : false
peut se détendre : true

▶ Essayez par vous-même

Diviser par zéro ferait planter le programme. Comme count != 0 vient en premier et vaut false, la division ne s’exécute tout simplement jamais. Inversez les deux côtés (total / count > 10 && count != 0) et la division passerait en premier. Ici, le compilateur le remarque même et refuse de compiler (« this operation will panic at runtime », c’est-à-dire « cette opération provoquera une panic à l’exécution ») ; avec une valeur connue seulement pendant l’exécution, le programme planterait. Placez donc la « vérification de sécurité » à gauche.

Astuce

Avec un booléen, vous n’avez jamais besoin de == true ou == false. Écrivez if is_ready plutôt que if is_ready == true, et if !is_ready plutôt que if is_ready == false. Cela veut dire exactement la même chose et se lit plus naturellement.

Exercices

1. Peut-il monter dans le manège ?

Un manège accepte les enfants qui mesurent au moins 120 cm, ou qui ont au moins 8 ans et sont accompagnés d’un adulte. Stockez une taille de 115, un âge de 9 et with_adult = true, puis affichez si cet enfant peut monter. Indice : utilisez des parenthèses pour regrouper la partie « âge et adulte ».

Voir la solution

fn main() {
    let height_cm = 115;
    let age = 9;
    let with_adult = true;

    let tall_enough = height_cm >= 120;
    let can_ride = tall_enough || (age >= 8 && with_adult);

    println!("assez grand : {tall_enough}");
    println!("peut monter : {can_ride}");
}

Sortie :

assez grand : false
peut monter : true

▶ Essayez par vous-même

2. Années bissextiles

Une année est bissextile si elle est divisible par 4 mais pas par 100, ou si elle est divisible par 400. Calculez un booléen is_leap pour 2024, affichez-le, puis faites de même pour 1900. Indice : « divisible par 4 » s’écrit year % 4 == 0, et vous pouvez masquer (shadowing) year et is_leap avec un second let.

Voir la solution

fn main() {
    let year = 2024;
    let is_leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    println!("{year} est bissextile : {is_leap}");

    let year = 1900;
    let is_leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    println!("{year} est bissextile : {is_leap}");
}

Sortie :

2024 est bissextile : true
1900 est bissextile : false

▶ Essayez par vous-même

Récapitulatif

• bool contient exactement deux valeurs : true ou false.
• Les comparaisons (==, <, >=, …) produisent des booléens.
• La condition d’un if doit être un vrai bool : aucune conversion implicite depuis un nombre ou une chaîne.
• && et || court-circuitent : ils sautent le côté droit dès que la réponse est connue. Placez donc les vérifications de sécurité à gauche.

Petit quiz

Petit quiz

1. Quel type produit une comparaison comme age >= 18 ?

Un bool Un entier Une chaîne de caractères

2. En Rust, peut-on utiliser directement un entier comme 0 comme condition d'un if, comme dans certains autres langages ?

Oui, 0 est considéré comme faux Non, la condition doit être un vrai bool Oui, mais seulement pour i32

3. Dans count != 0 && total / count > 10, que se passe-t-il quand count vaut 0 ?

Le programme plante à cause de la division par zéro Rust s'arrête après count != 0 et l'expression entière vaut false Le code ne compile pas

Score : 0 / 3

Pour aller plus loin

• The Boolean Type — The Rust Book (en anglais) : la courte présentation officielle de bool, avec les autres types de base.
• bool — documentation de la bibliothèque standard (en anglais) : toutes les méthodes de bool, comme then et then_some, pour quand vous serez prêt.
• Lazy boolean operators — The Rust Reference (en anglais) : les règles exactes qui font que && et || sautent leur côté droit.
• Primitives — Rust by Example (en anglais) : bool aux côtés des autres types intégrés de Rust, avec un exemple exécutable.