Условные конструкции и ветвление в Rust

Введение. Блок кода (Code Block) и выражения

#

Блок кода в Rust является фундаментальной синтаксической единицей. Он не просто группирует инструкции, но и сам по себе является выражением, возвращающим значение.

• Синтаксис: Ограничивается фигурными скобками { ... }. Внутри блока может содержаться набор инструкций, завершающихся точкой с запятой ;.
• Возвращаемое значение:
  • Если последняя строка блока является выражением без точки с запятой в конце, её результат становится возвращаемым значением всего блока кода.
  • Если последняя строка завершается точкой с запятой ; (или блок кода пуст), блок возвращает тип () (пустой кортеж / unit-тип).

Давайте изучим блоки кода, синтаксис if-else и сопоставления на интерактивных слайдах:

 1fn main() {
 2    // Блок кода вычисляется в значение последнего выражения
 3    let y = {
 4        let x = 1;
 5        let z = 2;
 6        x + z // Нет точки с запятой в конце -> возвращает 3
 7    };
 8
 9    // Блок кода завершающийся точкой с запятой возвращает ()
10    let u = {
11        let x = 10;
12        println!("x = {}", x);
13    };
14
15    println!("y = {}, u = {:?}", y, u);
16}

 1fn main() {
 2    let x = 150;
 3
 4    // В Rust if-else является выражением и может возвращать значение
 5    let y = if x > 100 {
 6        2024
 7    } else {
 8        2025
 9    };
10
11    println!("y = {}", y);
12
13    // ОШИБКА КОМПИЛЯЦИИ: типы веток if-else должны быть одинаковыми!
14    // let z = if x > 100 { 2024 } else { "2025" };
15}

 1fn main() {
 2    let some_val: Option<i32> = Some(150);
 3
 4    // Использование if let для простого сопоставления с шаблоном
 5    if let Some(x) = some_val {
 6        println!("Совпало! x = {}", x);
 7    }
 8
 9    let another_val: Option<i32> = Some(50);
10
11    // Начиная с Rust 1.88 поддерживаются цепочки if let с && (let_chains)
12    if let Some(x) = some_val && let Some(y) = another_val && x > y {
13        println!("Обе переменные извлечены, и x ({}) > y ({})", x, y);
14    }
15}

Условные конструкции и ветвление

#

Базовое выражение if и else

#

Конструкция if проверяет истинность условия и выполняет соответствующую ветку кода.

• Правила синтаксиса:
  • Выражение условия не нужно оборачивать в круглые скобки ( ). Использование круглых скобок вокруг самого выражения условия (например, if (a > 5)) считается нарушением стиля.
  • Результат условного выражения строго обязан иметь тип bool. Использование целых чисел (как в C/C++) приведет к ошибке компиляции.

// ОШИБКА КОМПИЛЯЦИИ: count имеет тип отличный от bool
if count { ... } 

// КОРРЕКТНО: выражения возвращают bool
if count > 0 { ... }
if count != 0 { ... }

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

#

Используются для формирования условных выражений:

• > (больше), >= (больше либо равно)
• < (меньше), <= (меньше либо равно)
• == (равенство), != (неравенство)
• && (логическое И), || (логическое ИЛИ)

if как выражение (Assigning from if)

#

В Rust if-else является выражением, а значит, может возвращать значение, которое можно присвоить переменной.

• Критическое правило типов: Все ветви конструкции if-else при использовании в качестве выражения обязаны возвращать один и тот же тип данных.
• В Rust нет классического тернарного оператора ? :. Вместо него используется if-else.

// Корректно: обе ветки возвращают i32
let y = if x > 100 { 2024 } else { 2025 }; 

// ОШИБКА КОМПИЛЯЦИИ (Несовпадение типов: i32 и &str):
let y = if x > 100 { 2024 } else { "2025" }; 

Если ветка else отсутствует, то выражение if обязано возвращать unit-тип (), так как если условие не выполнится, результатом по умолчанию будет ():

let u = if x > 100 { foo() }; // Допустимо, только если foo() возвращает ()

Конструкция if let и сопоставление с шаблоном

#

Базовый if let

#

Используется как лаконичная альтернатива match, когда нас интересует только один конкретный шаблон.

// Для Option
if let Some(x) = foo_opt() {
    bar(x); // x доступен только внутри этого блока
} else {
    // Выполняется, если результат None
}

Цепочки if let (let-chains)

#

Начиная с версии Rust 1.88, поддерживается синтаксис объединения нескольких let-шаблонов и логических условий через оператор && в одном выражении if.

// Сопоставление с шаблоном + дополнительное ограничение на переменную x
if let Some(x) = foo() && x > 100 {
    todo!()
}

// Множественные сопоставления с шаблонами в одном условии
if let Some(x) = foo() && let Some(y) = bar() && x > y {
    todo!()
}

Проверь свои знания!

#

Пройдите короткий интерактивный тест, чтобы закрепить понимание блоков кода и ветвлений в Rust.