Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Краткий поток управления с if let и let...else

Синтаксис if let позволяет объединить if и let в менее многословный способ обработки значений, соответствующих одному шаблону, игнорируя остальные. Рассмотрим программу в листинге 6-6, которая выполняет сопоставление с значением Option<u8> в переменной config_max, но хочет выполнить код только если значение является вариантом Some.

fn main() {
    let config_max = Some(3u8);
    match config_max {
        Some(max) => println!("The maximum is configured to be {max}"),
        _ => (),
    }
}
Листинг 6-6: match, который заботится только о выполнении кода, когда значение — Some

Если значение — Some, мы печатаем значение в варианте Some, привязывая значение к переменной max в шаблоне. Мы не хотим ничего делать со значением None. Чтобы удовлетворить выражение match, нам нужно добавить _ => () после обработки только одного варианта, что является раздражающим шаблонным кодом, который нужно добавить.

Вместо этого мы могли бы написать это короче, используя if let. Следующий код ведёт себя так же, как match в листинге 6-6:

fn main() {
    let config_max = Some(3u8);
    if let Some(max) = config_max {
        println!("The maximum is configured to be {max}");
    }
}

Синтаксис if let принимает шаблон и выражение, разделённые знаком равенства. Он работает так же, как match, где выражение передаётся в match, а шаблон является его первой ветвью. В этом случае шаблон — Some(max), и max привязывается к значению внутри Some. Затем мы можем использовать max в теле блока if let так же, как мы использовали max в соответствующей ветви match. Код в блоке if let выполняется только если значение соответствует шаблону.

Использование if let означает меньше набора текста, меньше отступов и меньше шаблонного кода. Однако вы теряете исчерпывающую проверку, которую обеспечивает match, гарантирующую, что вы не забыли обработать какие-либо случаи. Выбор между match и if let зависит от того, что вы делаете в конкретной ситуации, и от того, является ли получение краткости подходящим компромиссом за потерю исчерпывающей проверки.

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

Мы можем включить else в if let. Блок кода, который идёт с else, совпадает с блоком кода, который шёл бы с случаем _ в выражении match, эквивалентном if let и else. Вспомним определение перечисления Coin в листинге 6-4, где вариант Quarter также содержал значение UsState. Если бы мы хотели подсчитать все монеты не-кварталы, которые мы видим, а также объявить штат кварталов, мы могли бы сделать это с помощью match выражения, вот так:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let coin = Coin::Penny;
    let mut count = 0;
    match coin {
        Coin::Quarter(state) => println!("State quarter from {state:?}!"),
        _ => count += 1,
    }
}

Или мы могли бы использовать выражение if let и else, вот так:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let coin = Coin::Penny;
    let mut count = 0;
    if let Coin::Quarter(state) = coin {
        println!("State quarter from {state:?}!");
    } else {
        count += 1;
    }
}

Оставаться на «счастливом пути» с let...else

Распространённый паттерн — выполнить некоторое вычисление, когда значение присутствует, и вернуть значение по умолчанию в противном случае. Продолжая наш пример с монетами со значением UsState, если бы мы хотели сказать что-то забавное в зависимости от того, насколько старый штат на квартале, мы могли бы добавить метод в UsState для проверки возраста штата, вот так:

#[derive(Debug)] // чтобы мы могли проверить состояние через минуту
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    if let Coin::Quarter(state) = coin {
        if state.existed_in(1900) {
            Some(format!("{state:?} is pretty old, for America!"))
        } else {
            Some(format!("{state:?} is relatively new."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}

Затем мы могли бы использовать if let для сопоставления с типом монеты, вводя переменную state внутри тела условия, как в листинге 6-7.

#[derive(Debug)] // чтобы мы могли проверить состояние через минуту
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    if let Coin::Quarter(state) = coin {
        if state.existed_in(1900) {
            Some(format!("{state:?} is pretty old, for America!"))
        } else {
            Some(format!("{state:?} is relatively new."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}
Листинг 6-7: Проверка, существовал ли штат в 1900 году, с помощью условных выражений, вложенных в if let

Это делает работу, но это переместило работу в тело оператора if let, и если работа, которую нужно выполнить, более сложная, может быть трудно проследить, как именно связаны ветви верхнего уровня. Мы могли бы также воспользоваться тем, что выражения производят значение, чтобы либо произвести state из if let, либо вернуться раньше, как в листинге 6-8. (Вы могли бы сделать что-то подобное с match, тоже.)

#[derive(Debug)] // чтобы мы могли проверить состояние через минуту
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    let state = if let Coin::Quarter(state) = coin {
        state
    } else {
        return None;
    };

    if state.existed_in(1900) {
        Some(format!("{state:?} is pretty old, for America!"))
    } else {
        Some(format!("{state:?} is relatively new."))
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}
Листинг 6-8: Использование if let для создания значения или раннего возврата

Это несколько раздражает и само по себе! Одна ветвь if let создаёт значение, а другая полностью возвращается из функции.

Чтобы сделать этот распространённый паттерн проще для выражения, в Rust есть let...else. Синтаксис let...else принимает шаблон слева и выражение справа, очень похоже на if let, но у него нет ветви if, только ветвь else. Если шаблон совпадает, он привяжет значение из шаблона во внешней области видимости. Если шаблон не совпадает, программа перейдёт в ветвь else, которая должна вернуться из функции.

В листинге 6-9 вы можете увидеть, как выглядит листинг 6-8 при использовании let...else вместо if let.

#[derive(Debug)] // чтобы мы могли проверить состояние через минуту
enum UsState {
    Alabama,
    Alaska,
    // --snip--
}

impl UsState {
    fn existed_in(&self, year: u16) -> bool {
        match self {
            UsState::Alabama => year >= 1819,
            UsState::Alaska => year >= 1959,
            // -- snip --
        }
    }
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn describe_state_quarter(coin: Coin) -> Option<String> {
    let Coin::Quarter(state) = coin else {
        return None;
    };

    if state.existed_in(1900) {
        Some(format!("{state:?} is pretty old, for America!"))
    } else {
        Some(format!("{state:?} is relatively new."))
    }
}

fn main() {
    if let Some(desc) = describe_state_quarter(Coin::Quarter(UsState::Alaska)) {
        println!("{desc}");
    }
}
Листинг 6-9: Использование let...else для прояснения потока через функцию

Обратите внимание, что так остаётся на «счастливом пути» в теле функции, без существенно различного потока управления для двух ветвей, как было в if let.

Если у вас есть ситуация, в которой ваша программа имеет логику, слишком многословную для выражения с помощью match, помните, что if let и let...else также есть в вашем арсенале Rust.

Итог

Теперь мы рассмотрели, как использовать перечисления для создания пользовательских типов, которые могут быть одним из набора перечисленных значений. Мы показали, как тип Option<T> из стандартной библиотеки помогает использовать систему типов для предотвращения ошибок. Когда значения перечисления имеют данные внутри, вы можете использовать match или if let для извлечения и использования этих значений, в зависимости от того, сколько случаев вам нужно обработать.

Ваши программы на Rust теперь могут выражать концепции вашей предметной области с помощью структур и перечислений. Создание пользовательских типов для использования в вашем API обеспечивает безопасность типов: компилятор удостоверится, что ваши функции получают только значения типа, который каждая функция ожидает.

Чтобы предоставить вашим пользователям хорошо организованный API, который прост в использовании и раскрывает ровно то, что нужно вашим пользователям, давайте теперь обратимся к модулям Rust.