Opérateurs logiques, partie 1

Fait partie de la section Fundamentals du Journey Rust de Coddy — leçon 20 sur 75.

Les opérateurs logiques sont utilisés pour vérifier des combinaisons de comparaisons qui renvoient true ou false.

Par exemple, l'énoncé suivant contient deux comparaisons :

Est-ce que 5 est plus grand que 3 et plus petit que 6 ?

Opérateur	Signification	Exemple
`&&`	Et - `true` si tous les opérandes sont `true`	`a && b`
`\|\|`	Ou - `true` si au moins un opérande est `true`	`a \|\| b`
`!`	Non - `true` si l'opérande est `false`	`!a`

Voyons quelques exemples,

5 est plus grand que 3 et 1 est égal à 1,

let b1: bool = (5 > 3) && (1 == 1); // est vrai

Explication : Tous les opérandes sont true, donc b1 vaudra true (l'opération and est true si les deux opérandes sont true) .

5 n'est pas égal à 4 ou 5 est égal à 2,

let b2: bool = !(5 == 4) || (5 == 2); // est vrai

Explication : Le premier opérande (5 != 4) est true, donc b2 est également true (l'opération or est true si l'un ou l'autre des opérandes est true)

1 n'est pas égal à 1 ou faux,

let b3: bool = !(1 == 1) || false; // vaut false

Explication : Tous les opérandes sont false, donc b3 contiendra false (opération or).

non (3 est plus grand que 4),

let b4: bool = !(3 > 4); // vaut true

Explication : L'opérande est false, donc b4 vaudra true (opération not).

non (5 est plus grand que 10 ou 5 est plus grand que 1),

let b5: bool = !(5 > 10 || 5 > 1); // vaut false

Explication : 5 > 10 || 5 > 1 est true (l'une des opérandes est true), donc au total b5 est false (opération not).

Défi

Débutant

Un code vous est fourni. Remplacez les points d'interrogation des variables b1 et b2 par des valeurs booléennes pour que b3 contienne true.

Il existe plus d'une solution correcte.

Aide-mémoire

Les opérateurs logiques sont utilisés pour vérifier des combinaisons de comparaisons qui renvoient true ou false.

Opérateur	Signification	Exemple
`&&`	Et - `true` si tous les opérandes sont `true`	`a && b`
`\|\|`	Ou - `true` si au moins un opérande est `true`	`a \|\| b`
`!`	Non - `true` si l'opérande est `false`	`!a`

Exemples :

let b1: bool = (5 > 3) && (1 == 1); // true (les deux opérandes sont vrais)
let b2: bool = !(5 == 4) || (5 == 2); // true (le premier opérande est vrai)
let b3: bool = !(1 == 1) || false; // false (les deux opérandes sont faux)
let b4: bool = !(3 > 4); // true (l'opérande est faux, donc l'opération "not" renvoie vrai)
let b5: bool = !(5 > 10 || 5 > 1); // false (l'expression à l'intérieur est vraie, donc l'opération "not" renvoie faux)

Essayez vous-même

fn main() {
    // Tapez votre code ci-dessous
    let b1: bool = ?;
    let b2: bool = ?;
    let b3: bool = b1 || b2;
    
    // Ne modifiez pas la ligne ci-dessous
    println!("b3 = {}", b3);
}