Операторы сравнения и логические операторы в Rust

Что это и зачем?

Представь, что ты — капитан космического корабля. Твой компьютер должен принимать решения: «Если топлива больше 10 литров — летим дальше, иначе — заправка». Или: «Если на радаре есть враг И щиты включены — атакуй». Операторы сравнения и логические операторы — это те самые «если», «и», «или», «не» в программировании. Они помогают программе выбирать, что делать, в зависимости от данных.

В Rust эти операторы выглядят немного строже, чем в математике, но зато не дают ошибиться. Например, ты не сможешь случайно перепутать «равно» с «присвоить» — компилятор сразу укажет на ошибку.

Синтаксис и примеры кода

Вот как выглядят основные операторы сравнения в Rust:

• == — равно (проверяет, одинаковы ли значения)
• != — не равно
• > — больше
• < — меньше
• >= — больше или равно
• <= — меньше или равно

Логические операторы:

• && — логическое «И» (всё должно быть истинно)
• || — логическое «ИЛИ» (хотя бы одно истинно)
• ! — логическое «НЕ» (переворачивает истину на ложь)

Пример 1: Проверка возраста для просмотра фильма

fn main() {
    let возраст = 14;
    let минимальный_возраст = 12;
    
    // Проверяем, можно ли смотреть фильм
    let можно_смотреть = возраст >= минимальный_возраст;
    println!("Можно смотреть фильм? {}", можно_смотреть); // Выведет: true
}

Здесь возраст >= минимальный_возраст — это сравнение. Если возраст 14, а нужно 12, то условие истинно (true). Если бы возраст был 10, получили бы false.

Пример 2: Проверка пароля (логическое И)

fn main() {
    let пароль = "secret123";
    let подтверждение = "secret123";
    
    // Должны совпасть оба условия
    let пароли_совпадают = (пароль == "secret123") && (подтверждение == "secret123");
    println!("Пароли совпадают? {}", пароли_совпадают); // true
}

Оператор && требует, чтобы оба сравнения были истинными. Если хоть одно неверно — результат false.

Пример 3: Выбор завтрака (логическое ИЛИ)

fn main() {
    let есть_яйца = false;
    let есть_хлеб = true;
    
    // Можно сделать бутерброд или яичницу
    let можно_поесть = есть_яйца || есть_хлеб;
    println!("Можно позавтракать? {}", можно_поесть); // true (хотя бы хлеб есть)
}

|| даёт true, если хотя бы одно условие верно. Если бы не было ни яиц, ни хлеба — было бы false.

Пример 4: Проверка, что число не равно нулю (логическое НЕ)

fn main() {
    let число = 7;
    let не_ноль = !(число == 0); // То же самое, что число != 0
    println!("Число не ноль? {}", не_ноль); // true
}

Оператор ! переворачивает true на false и наоборот. Если число равно 0, то число == 0 — true, а !(true) — false.

Пример 5: Сложное условие для игры

fn main() {
    let здоровье = 80;
    let есть_щит = true;
    let враг_рядом = false;
    
    // Атакуем, если здоровье > 50 И есть щит, ИЛИ враг очень близко
    let атаковать = (здоровье > 50 && есть_щит) || враг_рядом;
    println!("Атаковать? {}", атаковать); // true (здоровье 80 > 50 и щит есть)
}

Здесь мы комбинируем операторы. Сначала вычисляется здоровье > 50 && есть_щит (true), потом true || false даёт true.

Сравнение с Python

В Python те же операторы выглядят почти так же, но есть важные отличия:

• В Python логические операторы пишутся словами: and, or, not (в Rust — символами: &&, ||, !).
• В Python можно писать 5 < x < 10 (проверка, что x между 5 и 10). В Rust так нельзя — нужно писать x > 5 && x < 10.
• В Python == и != работают так же, но в Rust строже с типами: нельзя сравнить число и строку напрямую.

Пример на Python:

возраст = 14
минимальный = 12
можно = возраст >= минимальный  # True
print(можно)

# Логические операторы словами
пароль = "secret"
подтверждение = "secret"
совпадают = (пароль == "secret") and (подтверждение == "secret")
print(совпадают)  # True

Как видишь, логика та же, но синтаксис разный. Rust использует символы, потому что они короче и чётче, а Python — английские слова для читаемости.

Типичные ошибки новичков

• Путают = и ==. В Rust = — это присваивание (положить значение в переменную), а == — сравнение. Если написать if x = 5, компилятор выдаст ошибку.
• Забывают про приоритет операций. Например, здоровье > 50 && есть_щит || враг_рядом может сработать не так, как ты думаешь. Всегда используй скобки: (здоровье > 50 && есть_щит) || враг_рядом.
• Пытаются сравнить разные типы. В Rust нельзя написать 5 == "5" — число и строку нельзя сравнивать. Нужно сначала преобразовать: 5 == "5".parse().unwrap().
• Используют && вместо &. & — это оператор взятия ссылки, а не логическое «И». Новички часто путают.
• Думают, что ! меняет переменную. !x не меняет саму переменную x, а только возвращает противоположное значение. Чтобы изменить, нужно написать x = !x.

Итог

Операторы сравнения и логические операторы — это основа любого принятия решений в программировании. В Rust они строгие и не прощают ошибок, но именно это помогает тебе писать надёжный код с самого начала. Запомни главное:

• Сравнения всегда возвращают true или false.
• && — всё должно быть правдой, || — хотя бы одно, ! — наоборот.
• Всегда ставь скобки в сложных условиях.
• Не путай = и == — это разные вещи.

Попробуй написать свою программу с этими операторами — например, калькулятор, который проверяет, можно ли купить билет в кино (возраст и наличие денег). Удачи в космических приключениях с Rust!