Operadores Lógicos Parte 1

Parte da seção Fundamentals do Journey de Rust da Coddy — lição 20 de 75.

Operadores lógicos são usados para verificar combinações de comparações que retornam true ou false.

Por exemplo, a seguinte instrução contém duas comparações:

5 é maior que 3 e menor que 6?

Operador	Significado	Exemplo
`&&`	E - `true` se todos os operandos forem `true`	`a && b`
`\|\|`	Ou - `true` se qualquer operando for `true`	`a \|\| b`
`!`	Não - `true` se o operando for `false`	`!a`

Vejamos alguns exemplos,

5 é maior que 3 e 1 é igual a 1,

let b1: bool = (5 > 3) && (1 == 1); // resulta em true

Explicação: Todos os operandos são true, então b1 conterá true (a operação and é true se ambos os operandos forem true) .

5 não é igual a 4 ou 5 é igual a 2,

let b2: bool = !(5 == 4) || (5 == 2); // resulta em verdadeiro

Explicação: O primeiro operando (5 != 4) é true, então b2 também é true (a operação or é true se qualquer um dos operandos for true)

1 não é igual a 1 ou falso,

let b3: bool = !(1 == 1) || false; // contém false

Explicação: Todos os operandos são false, então b3 conterá false (operação or).

não (3 é maior que 4),

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

Explicação: O operando é false, então b4 conterá true (operação not).

não (5 é maior que 10 ou 5 é maior que 1),

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

Explicação: 5 > 10 || 5 > 1 é true (um dos operandos é true), então no total b5 é false (operação not).

Desafio

Iniciante

Você recebeu um código, substitua os pontos de interrogação das variáveis b1 e b2 por valores booleanos para que b3 contenha true.

Existe mais de uma solução correta.

Folha de consulta

Operadores lógicos são usados para verificar combinações de comparações que retornam true ou false.

Operador	Significado	Exemplo
`&&`	And (E) - `true` se todos os operandos forem `true`	`a && b`
`\|\|`	Or (Ou) - `true` se qualquer operando for `true`	`a \|\| b`
`!`	Not (Não) - `true` se o operando for `false`	`!a`

Exemplos:

let b1: bool = (5 > 3) && (1 == 1); // true (ambos os operandos são true)
let b2: bool = !(5 == 4) || (5 == 2); // true (o primeiro operando é true)
let b3: bool = !(1 == 1) || false; // false (ambos os operandos são false)
let b4: bool = !(3 > 4); // true (o operando é false, então a operação not retorna true)
let b5: bool = !(5 > 10 || 5 > 1); // false (a expressão interna é true, então a operação not retorna false)

Experimente você mesmo

fn main() {
    // Digite seu código abaixo
    let b1: bool = ?;
    let b2: bool = ?;
    let b3: bool = b1 || b2;
    
    // Não altere a linha abaixo
    println!("b3 = {}", b3);
}