Операторы в Rust

Операторы — это символы, с помощью которых считают, сравнивают значения и объединяют условия. Если ты писал на любом C-подобном языке, большинство из них покажутся знакомыми.

Арифметические операторы

fn main() {
    let a = 10;
    let b = 3;

    println!("{}", a + b); // 13
    println!("{}", a - b); // 7
    println!("{}", a * b); // 30
    println!("{}", a / b); // 3  (целочисленное деление, остаток отбрасывается)
    println!("{}", a % b); // 1  (остаток)
}

▶ Попробуй сам

Осторожно

a / b для двух целых чисел — это целочисленное деление: 10 / 3 равно 3, а не 3.333.... Если нужен дробный результат, хотя бы одна сторона должна быть числом с плавающей точкой: 10.0 / 3.0.

Операторы сравнения

Они сравнивают два значения и возвращают bool:

fn main() {
    let a = 5;
    let b = 8;

    println!("{}", a == b); // false
    println!("{}", a != b); // true
    println!("{}", a < b);  // true
    println!("{}", a > b);  // false
    println!("{}", a <= b); // true
    println!("{}", a >= b); // false
}

Ты будешь постоянно использовать их в условиях if, о которых рассказывает урок If…Else.

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

Логические операторы объединяют или инвертируют логические значения:

fn main() {
    let is_logged_in = true;
    let is_admin = false;

    println!("{}", is_logged_in && is_admin); // false — оба должны быть true
    println!("{}", is_logged_in || is_admin); // true  — хотя бы одно true
    println!("{}", !is_admin);                // true  — меняет false на true
}

▶ Попробуй сам

• && — и: true, только если обе стороны true.
• || — или: true, если хотя бы одна сторона true.
• ! — не: меняет true на false и наоборот.

Операторы присваивания

Кроме обычного =, в Rust есть сокращённые операторы, которые обновляют переменную на основе её текущего значения:

fn main() {
    let mut score = 10;

    score += 5; // то же, что score = score + 5
    score -= 2; // score = score - 2
    score *= 3; // score = score * 3
    score /= 2; // score = score / 2

    println!("{score}");
}

▶ Попробуй сам

Помни: чтобы всё это скомпилировалось, переменной нужен mut — ты ведь меняешь её значение.

Заметка

В Rust нет операторов ++ и --. Чтобы прибавить к счётчику единицу, пиши count += 1. Это на один символ длиннее, зато не оставляет никаких сомнений, что происходит.

Порядок выполнения (приоритет)

Когда в выражении несколько операторов, Rust не идёт просто слева направо. Как в школьной математике, *, / и % выполняются раньше + и -. Операторы одного уровня выполняются слева направо. Скобки всегда идут первыми, так что ставь их, когда нужен другой порядок.

fn main() {
    let a = 2 + 3 * 4;            // сначала *: 2 + 12
    let b = (2 + 3) * 4;          // сначала скобки: 5 * 4
    let c = 10 - 4 - 3;           // один уровень, слева направо: (10 - 4) - 3
    let d = 17 % 5 * 2;           // один уровень, слева направо: (17 % 5) * 2
    let ok = 1 + 1 == 2 && 3 > 2; // арифметика, потом сравнения, потом &&

    println!("{a} {b} {c} {d} {ok}");
}

Вывод:

14 20 3 4 true

▶ Попробуй сам

Полный порядок, от первого к последнему, примерно такой: арифметика (* / %, затем + -), потом сравнения (== != < > <= >=), потом &&, потом || и в самом конце операторы присваивания (= += -= и компания). Поэтому 1 + 1 == 2 && 3 > 2 работает без всяких скобок. И всё же, если тебе приходится останавливаться и вспоминать порядок, поставь скобки. Они ничего не стоят, а код становится понятнее.

Осторожно

Сравнения нельзя записывать цепочкой, как в математике. 1 < x < 5 — ошибка компиляции («comparison operators cannot be chained», операторы сравнения нельзя объединять в цепочку). Запиши это как два сравнения, соединённых &&: 1 < x && x < 5.

Практика

1. Минуты и секунды

Видео длится 125 секунд. Сохрани это число в переменной, а затем выведи, сколько это целых минут и оставшихся секунд, например Длительность: 2 мин 5 с. Подсказка: целочисленное деление / даёт целые минуты, а % — то, что осталось.

Показать решение

fn main() {
    let total_seconds = 125;

    let minutes = total_seconds / 60; // 2 (остаток отбрасывается)
    let seconds = total_seconds % 60; // 5 (остаток)

    println!("Длительность: {minutes} мин {seconds} с");
}

Вывод:

Длительность: 2 мин 5 с

▶ Попробуй сам

2. Считаем очки

Начни игровой счёт score с 10. Прибавь 25, отними 5, затем удвой его — с помощью сокращённых операторов присваивания. Выведи счёт, набрано ли хотя бы 50 очков, и набрано ли хотя бы 50 и при этом число чётное. Подсказка: число чётное, когда score % 2 == 0.

Показать решение

fn main() {
    let mut score = 10;

    score += 25; // 35
    score -= 5;  // 30
    score *= 2;  // 60

    println!("счёт: {score}");
    println!("уровень пройден? {}", score >= 50);
    println!("пройден и чётный? {}", score >= 50 && score % 2 == 0);
}

Вывод:

счёт: 60
уровень пройден? true
пройден и чётный? true

▶ Попробуй сам

Итоги

• Арифметика: + - * / %. Целочисленное деление отбрасывает дробную часть.
• Сравнение: == != < > <= >=, все возвращают bool.
• Логика: && (и), || (или), ! (не).
• Сокращённое присваивание: += -= *= /= обновляют переменную с mut на месте. ++ нет.
• * / % выполняются раньше + -, а арифметика — раньше сравнений и &&/||. Сомневаешься — ставь скобки.

Проверь себя

Проверь себя

1. Чему равно 10 / 3, если обе стороны — целые числа?

3.333... 3 4

2. Какой тип всегда возвращают операторы сравнения вроде == и <?

i32 String bool

3. Что нужно, чтобы score += 5; скомпилировалось?

score должна быть объявлена с mut score должна иметь тип f64 Ничего особенного — это всегда компилируется

Результат: 0 / 3

Что почитать

• B — Операторы и символы — книга «Язык программирования Rust»: таблица на одну страницу со всеми операторами Rust и тем, что они делают (перевод на русский).
• Литералы и операторы — Rust на примерах: короткие примеры арифметических, логических и побитовых операторов, которые можно запустить (перевод на русский).
• Expression precedence — The Rust Reference (на английском): точный порядок, в котором Rust выполняет операторы, от первого к последнему.
• Operator expressions — The Rust Reference (на английском): точные правила для каждого оператора, включая то, что происходит при переполнении целых чисел.