Mantıksal Operatörler Bölüm 1

Coddy'nin Rust Journey'sinin Fundamentals bölümünün bir parçası — ders 20 / 75.

Mantıksal operatörler, true veya false döndüren karşılaştırma kombinasyonlarını kontrol etmek için kullanılır.

Örneğin, aşağıdaki ifade iki karşılaştırma içerir:

5, 3'ten büyük ve 6'dan küçük mü?

Operatör	Anlamı	Örnek
`&&`	Ve - tüm işlenenler `true` ise `true`	`a && b`
`\|\|`	Veya - herhangi bir işlenen `true` ise `true`	`a \|\| b`
`!`	Değil - işlenen `false` ise `true`	`!a`

Bazı örneklere bakalım,

5, 3'ten büyüktür ve 1, 1'e eşittir,

let b1: bool = (5 > 3) && (1 == 1); // true değerini tutar

Açıklama: İşlenenlerin tamamı true'dur, bu nedenle b1, true değerini tutacaktır (and işlemi, her iki işlenen de true ise true sonucunu verir) .

5, 4'e eşit değildir veya 5, 2'ye eşittir,

let b2: bool = !(5 == 4) || (5 == 2); // true değerini tutar

Açıklama: İlk işlenen (5 != 4) true olduğu için b2 de true olur (işlenenlerden herhangi biri true ise or işlemi true sonucunu verir)

1, 1'e eşit değildir veya false,

let b3: bool = !(1 == 1) || false; // false değerini tutar

Açıklama: Tüm operandlar false olduğundan, b3 false değerini tutacaktır (or işlemi).

değil (3, 4'ten büyüktür),

let b4: bool = !(3 > 4); // true değerini tutar

Açıklama: İşlemlenen değer false olduğundan, b4 değişkeni true değerini tutacaktır (not işlemi).

değil (5, 10'dan büyüktür veya 5, 1'den büyüktür),

let b5: bool = !(5 > 10 || 5 > 1); // false değerini tutar

Açıklama: 5 > 10 || 5 > 1 ifadesi true'dur (operanlardan biri true'dur), bu nedenle sonuç olarak b5 değeri false'tur (not işlemi).

Görev

Başlangıç

Size bir kod verilmiştir, b1 ve b2 değişkenlerinin soru işaretlerini Boolean değerlerle değiştirin, böylece b3, true değerini tutsun.

Birden fazla doğru çözüm vardır.

Kopya kağıdı

Mantıksal operatörler, true veya false döndüren karşılaştırma kombinasyonlarını kontrol etmek için kullanılır.

Operatör	Anlamı	Örnek
`&&`	Ve - tüm işlenenler `true` ise `true`	`a && b`
`\|\|`	Veya - işlenenlerden herhangi biri `true` ise `true`	`a \|\| b`
`!`	Değil - işlenen `false` ise `true`	`!a`

Örnekler:

let b1: bool = (5 > 3) && (1 == 1); // true (her iki işlenen de true)
let b2: bool = !(5 == 4) || (5 == 2); // true (ilk işlenen true)
let b3: bool = !(1 == 1) || false; // false (her iki işlenen de false)
let b4: bool = !(3 > 4); // true (işlenen false, bu yüzden değil işlemi true döndürür)
let b5: bool = !(5 > 10 || 5 > 1); // false (içerideki ifade true, bu yüzden değil işlemi false döndürür)

Kendin dene

fn main() {
    // Kodunuzu aşağıya yazın
    let b1: bool = ?;
    let b2: bool = ?;
    let b3: bool = b1 || b2;
    
    // Aşağıdaki satırı değiştirmeyin
    println!("b3 = {}", b3);
}