Условия и циклы в Rust: if, match, loop, for с примерами

Представь светофор: зелёный — едешь, красный — ждёшь. Программа тоже принимает решения в зависимости от условий. В Rust для этого есть несколько конструкций — и некоторые удивительно умные!

if — условное выражение (не просто оператор!)

В Rust if — это выражение: оно возвращает значение! В большинстве языков if — просто команда. В Rust это ещё и значение.

fn main() {
    let number = 7;

    if number < 5 {
        println!("Маленькое");
    } else if number < 10 {
        println!("Среднее");   // выведется это
    } else {
        println!("Большое");
    }

    // ВАЖНО: условие ОБЯЗАТЕЛЬНО bool в Rust!
    // if number { ... }  — ОШИБКА! (не как Python/JS)
    if number != 0 {
        println!("Не ноль!");
    }
}

if как выражение

fn main() {
    let age = 16;
    let status = if age >= 18 { "совершеннолетний" } else { "несовершеннолетний" };
    println!("Статус: {}", status);

    let score = 75u32;
    let grade = if score >= 90 { 5 }
                else if score >= 75 { 4 }
                else if score >= 60 { 3 }
                else { 2 };
    println!("Оценка: {}", grade);  // 4

    let max = if 3 > 5 { 3 } else { 5 };
    println!("Максимум: {}", max);  // 5

    // Обе ветки ОБЯЗАНЫ возвращать одинаковый тип:
    // let x = if true { 5 } else { "пять" };  — ОШИБКА!
}

loop — бесконечный цикл с возвратом значения

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;  // выходим и возвращаем значение!
        }
    };
    println!("counter={}, result={}", counter, result);  // 10, 20

    // Метки для вложенных циклов
    'outer: loop {
        let mut y = 0;
        loop {
            y += 1;
            if y == 3 { continue 'outer; }
            if y > 5   { break 'outer; }
        }
    }
    println!("Готово!");
}

while — цикл с условием

fn main() {
    let mut n = 5;
    while n > 0 {
        println!("{}...", n);
        n -= 1;
    }
    println!("🚀 ПУСК!");

    let mut sum = 0;
    let mut i = 0;
    while sum < 100 {
        i += 1;
        sum += i;
    }
    println!("1+2+...+{} = {} (первая сумма >= 100)", i, sum);
}

for — цикл по коллекции

fn main() {
    let fruits = ["яблоко", "банан", "вишня", "дыня"];

    // Простой обход
    for fruit in fruits {
        println!("Фрукт: {}", fruit);
    }

    // С индексом
    for (i, fruit) in fruits.iter().enumerate() {
        println!("{}: {}", i + 1, fruit);
    }

    // По вектору — & чтобы не перемещать данные
    let numbers = vec![10, 20, 30, 40, 50];
    let mut total = 0;
    for n in &numbers {
        total += n;
    }
    println!("Сумма: {}", total);
    println!("Вектор жив: {:?}", numbers);

    // Изменяем через &mut
    let mut scores = vec![85, 90, 78];
    for s in &mut scores {
        *s += 5;  // * — разыменование ссылки
    }
    println!("С бонусом: {:?}", scores);
}

Диапазоны (Range)

fn main() {
    // 1..10 — от 1 до 9 (НЕ включая 10)
    for i in 1..10 { print!("{} ", i); }
    println!();

    // 1..=10 — включая 10
    for i in 1..=10 { print!("{} ", i); }
    println!();

    // Обратный порядок
    for i in (1..=5).rev() { print!("{} ", i); }
    println!();

    // Шаг step_by
    for i in (0..=20).step_by(2) { print!("{} ", i); }
    println!();

    // Задача Гаусса
    let sum: i32 = (1..=100).sum();
    println!("1+2+...+100 = {}", sum);  // 5050

    // 10 факториал
    let fact: u64 = (1..=10).product();
    println!("10! = {}", fact);  // 3628800

    // Квадраты через map
    let sq: Vec = (1..=5).map(|n| n * n).collect();
    println!("{:?}", sq);  // [1, 4, 9, 16, 25]

    // Алфавит
    let abc: String = (b'a'..=b'z').map(|c| c as char).collect();
    println!("{}", abc);
}

match — замена switch, но умнее!

Компилятор требует обработать все возможные случаи. Забыл — не скомпилируется!

fn main() {
    let day = 3u32;
    let name = match day {
        1 => "Понедельник",
        2 => "Вторник",
        3 => "Среда",
        4 => "Четверг",
        5 => "Пятница",
        6 => "Суббота",
        7 => "Воскресенье",
        _ => "Неверный день",  // _ = всё остальное
    };
    println!("{}", name);

    // Несколько значений через |
    let is_weekend = match day { 6 | 7 => true, _ => false };
    println!("Выходной: {}", is_weekend);

    // Диапазон в match
    let score = 85u32;
    let grade = match score {
        90..=100 => "Отлично",
        75..=89  => "Хорошо",
        60..=74  => "Удовлетворительно",
        0..=59   => "Неудовлетворительно",
        _        => "Неверно",
    };
    println!("Оценка: {}", grade);

    // Захват значения через @
    let n = 13u32;
    let desc = match n {
        num @ 1..=9   => format!("Однозначное: {}", num),
        num @ 10..=99 => format!("Двузначное: {}", num),
        num           => format!("Большое: {}", num),
    };
    println!("{}", desc);

    // Guard (дополнительное условие)
    let pair = (2, -2i32);
    match pair {
        (x, y) if x + y == 0 => println!("{} + {} = 0", x, y),
        (x, _) if x % 2 == 0 => println!("Первое чётное: {}", x),
        _                     => println!("Другое"),
    }
}

match с enum

enum Shape {
    Circle(f64),
    Rectangle(f64, f64),
    Triangle(f64, f64, f64),
}

fn area(s: &Shape) -> f64 {
    match s {
        Shape::Circle(r)         => std::f64::consts::PI * r * r,
        Shape::Rectangle(w, h)   => w * h,
        Shape::Triangle(a, b, c) => {
            let s = (a + b + c) / 2.0;
            (s * (s-a) * (s-b) * (s-c)).sqrt()
        }
    }
}

fn main() {
    let shapes = vec![
        Shape::Circle(5.0),
        Shape::Rectangle(4.0, 6.0),
        Shape::Triangle(3.0, 4.0, 5.0),
    ];
    for shape in &shapes {
        println!("Площадь: {:.2}", area(shape));
    }
}

Практический пример: игра «Угадай число»

fn main() {
    let secret = 42u32;
    let guesses = [25, 60, 35, 45, 42];

    println!("🎮 Угадай число от 1 до 100!");

    let mut won = false;
    for (n, &guess) in guesses.iter().enumerate() {
        let hint = match guess.cmp(&secret) {
            std::cmp::Ordering::Less    => format!("⬆️  {} — меньше", guess),
            std::cmp::Ordering::Greater => format!("⬇️  {} — больше", guess),
            std::cmp::Ordering::Equal   => format!("🎉 {} — УГАДАЛ!", guess),
        };
        println!("Попытка {}: {}", n + 1, hint);
        if guess == secret { won = true; break; }
    }

    println!("{}", if won { "Победа!" } else { "Не угадал" });
}

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

❌ Условие не bool

if 5 { ... }  // error: expected `bool`, found integer
if 5 != 0 { ... }  // ✅

❌ Неполный match

match x {
    1 => ...,
    2 => ...,
    // error: non-exhaustive patterns
    _ => ...,  // добавь wildcard
}

Итого

if/else if/else — условие и выражение с возвращаемым значением. loop — бесконечный цикл; break значение возвращает результат. while условие. for x in коллекция. 1..10 — диапазон без 10; 1..=10 — включая. match — проверяет все случаи. Метки 'outer: для вложенных циклов.

Дополнительные примеры для практики

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

Задача 1: Числовые паттерны

fn main() {
    // Выведи пирамиду из звёздочек
    for i in 1..=5 {
        for _ in 0..i { print!("* "); }
        println!();
    }

    // Числа Фибоначчи итеративно (быстрее рекурсии)
    let mut a = 0u64;
    let mut b = 1u64;
    print!("Фибоначчи: ");
    for _ in 0..15 {
        print!("{} ", a);
        let c = a + b;
        a = b;
        b = c;
    }
    println!();

    // Простые числа через решето Эратосфена
    let n = 50usize;
    let mut is_prime = vec![true; n + 1];
    is_prime[0] = false;
    is_prime[1] = false;
    let mut i = 2;
    while i * i <= n {
        if is_prime[i] {
            let mut j = i * i;
            while j <= n {
                is_prime[j] = false;
                j += i;
            }
        }
        i += 1;
    }
    print!("Простые до {}: ", n);
    for k in 2..=n {
        if is_prime[k] { print!("{} ", k); }
    }
    println!();
}

Задача 2: Работа с данными

fn main() {
    let data = vec![
        ("Алиса", 85.0f64),
        ("Боря",  72.0),
        ("Вера",  91.0),
        ("Гриша", 68.0),
        ("Даша",  95.0),
    ];

    // Сортировка по убыванию
    let mut sorted = data.clone();
    sorted.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());

    println!("Топ учеников:");
    for (i, (name, score)) in sorted.iter().enumerate() {
        let medal = match i { 0 => "🥇", 1 => "🥈", 2 => "🥉", _ => "  " };
        println!("{} {} — {:.1}", medal, name, score);
    }

    let avg = data.iter().map(|(_, s)| s).sum::() / data.len() as f64;
    let above: Vec<_> = data.iter().filter(|(_, s)| *s > avg).collect();

    println!("
Средний балл: {:.2}", avg);
    println!("Выше среднего: {}", above.len());
}

Разбор типичных задач

// Палиндром
fn is_palindrome(s: &str) -> bool {
    let chars: Vec = s.chars().collect();
    let n = chars.len();
    for i in 0..n/2 {
        if chars[i] != chars[n-1-i] { return false; }
    }
    true
}

// FizzBuzz
fn fizzbuzz(n: u32) -> String {
    match (n % 3, n % 5) {
        (0, 0) => "FizzBuzz".to_string(),
        (0, _) => "Fizz".to_string(),
        (_, 0) => "Buzz".to_string(),
        _      => n.to_string(),
    }
}

// Подсчёт слов в тексте
fn word_frequencies(text: &str) -> std::collections::HashMap<&str, usize> {
    let mut freq = std::collections::HashMap::new();
    for word in text.split_whitespace() {
        *freq.entry(word).or_insert(0) += 1;
    }
    freq
}

fn main() {
    println!("'racecar' палиндром? {}", is_palindrome("racecar"));
    println!("'hello' палиндром? {}", is_palindrome("hello"));

    for n in 1..=20 { print!("{} ", fizzbuzz(n)); }
    println!();

    let text = "rust rust код код код программирование";
    let freq = word_frequencies(text);
    let mut pairs: Vec<_> = freq.iter().collect();
    pairs.sort_by(|a, b| b.1.cmp(a.1));
    for (word, count) in pairs {
        println!("'{}': {}", word, count);
    }
}