Обработка ошибок: panic, Result и ?

Отличай неисправимые ошибки (`panic!`) от исправимых (`Result`), пойми риски `unwrap` и `expect`, пиши короткий код с оператором `?` и создай собственный тип ошибки.

  • Средний
  • 18 мин
  • 10 вопросов
  • Урок 6 из 10

В этом уроке ты узнаешь

  • Правильно выбирать между паникой и Result
  • Обрабатывать Result через match, unwrap_or и expect
  • Передавать ошибку вызывающей функции оператором ?
  • Создавать собственное перечисление ошибок, реализующее Display

Ты спрашиваешь у пользователя возраст, а он вводит abc. Хочешь прочитать файл, а файла нет. Это не ошибки в программе, а ожидаемые ситуации — программа должна реагировать на них, не падая. Rust требует показывать все возможные неудачи в типах, и компилятор не даёт о них забыть.

Два вида ошибок

Неисправимая ошибка означает, что в программе баг: выход за границу массива или ситуация, которая «никогда не должна случиться». Тогда Rust паникует: печатает сообщение об ошибке и останавливает поток. Ты можешь и сам вызвать panic!("сообщение"). Исправимые ошибки возвращаются через тип Result<T, E>, и их обрабатывает вызывающий код.

Rust
fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("division by zero: {a} / {b}");
    }
    a / b
}

fn main() {
    println!("{}", divide(10, 2));
    println!("{}", divide(1, 0));
    println!("never printed");
}

Ожидаемый результат

5
thread 'main' panicked at src/main.rs:3:9:
division by zero: 1 / 0
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
Сообщение о панике выводится в стандартный поток ошибок (stderr) и указывает файл, строку и столбец; до последней строки дело не доходит. При выходе за границу массива появляется похожее сообщение: index out of bounds: the len is 3 but the index is 10.

Чтобы читать дальше, зарегистрируйся бесплатно

Остальные разделы урока, тест и заметки открываются с аккаунтом Educora. Регистрация занимает минуту, а прогресс сохраняется на всех твоих устройствах.

Тип Result

Result<T, E> — перечисление с двумя вариантами: Ok(T) при успехе и Err(E) при неудаче. Например, метод parse, превращающий текст в число, возвращает Result, ведь текст может и не быть числом. Через match мы обрабатываем оба случая отдельно:

Rust
fn main() {
    let inputs = ["42", "abc", ""];
    for input in inputs {
        match input.parse::<i32>() {
            Ok(n) => println!("{input:?} -> {}", n * 2),
            Err(e) => println!("{input:?} -> error: {e}"),
        }
    }
}

Ожидаемый результат

"42" -> 84
"abc" -> error: invalid digit found in string
"" -> error: cannot parse integer from empty string
В записи parse::<i32>() часть ::<i32> указывает, в какой тип преобразовать (её называют «турборыбой», turbofish). Ошибка печатается через {e} как понятный человеку текст.

unwrap, expect и другие сокращения

Rust
fn main() {
    let a: i32 = "7".parse().unwrap();
    let b: i32 = "8".parse().expect("b must be a number");
    let c: i32 = "x".parse().unwrap_or(0);
    let d: i32 = "".parse().unwrap_or_default();
    println!("{}", a + b + c + d);
}

Ожидаемый результат

15
Для c и d преобразование не удалось, но программа не остановилась: unwrap_or(0) и unwrap_or_default() вернули запасное значение (0). 7 + 8 + 0 + 0 = 15.
СпособПри ErrКогда применять
matchсвой код для каждого случаякогда нужен полный контроль
?возвращает ошибку вызывающемукогда функция сама возвращает Result
unwrap_or(v)возвращает vесли есть разумное запасное значение
expect("...")паника с твоим сообщениемесли неудача означает баг
unwrap()паникатолько в примерах и тестах

Оператор ?

? пишут после Result. Если результат Ok, ? достаёт значение, и код продолжается. Если Err — текущая функция сразу возвращает эту ошибку. Так ошибки передаются вызывающему коду без match на каждом шаге. Условие: функция сама должна возвращать Result (или Option).

Rust
use std::num::ParseIntError;

fn sum_pair(a: &str, b: &str) -> Result<i32, ParseIntError> {
    let x: i32 = a.trim().parse()?;
    let y: i32 = b.trim().parse()?;
    Ok(x + y)
}

fn main() {
    println!("{:?}", sum_pair("10", " 32 "));
    println!("{:?}", sum_pair("10", "ten"));
    match sum_pair("5", "") {
        Ok(total) => println!("total = {total}"),
        Err(e) => println!("failed: {e}"),
    }
}

Ожидаемый результат

Ok(42)
Err(ParseIntError { kind: InvalidDigit })
failed: cannot parse integer from empty string
trim() убирает пробелы по краям. {:?} показывает внутреннее устройство ошибки, а {e} — её понятное сообщение.

Без ?

use std::num::ParseIntError;

fn read_age(s: &str) -> Result<u8, ParseIntError> {
    let age = match s.parse::<u8>() {
        Ok(value) => value,
        Err(e) => return Err(e),
    };
    Ok(age)
}

С ?

use std::num::ParseIntError;

fn read_age(s: &str) -> Result<u8, ParseIntError> {
    let age = s.parse::<u8>()?;
    Ok(age)
}
Обе функции делают одно и то же. Увидев вариант слева, cargo clippy предложит заменить его на ? (правило question_mark).

Ошибка E0277

fn main() {
    let n: i32 = "5".parse()?;
    println!("{n}");
}

Правильно: выводит `5`

use std::num::ParseIntError;

fn main() -> Result<(), ParseIntError> {
    let n: i32 = "5".parse()?;
    println!("{n}");
    Ok(())
}
Обычная main ничего не возвращает, поэтому компилятор пишет: the ? operator can only be used in a function that returns Result or Option. main тоже может возвращать Result; при Err ошибка печатается, и программа завершается с кодом неудачи.

Собственный тип ошибки

В большой программе у ошибок должны быть собственные имена. Опиши виды ошибок как enum и реализуй для него трейт Display, чтобы ошибка показывалась пользователю понятным сообщением. Метод map_err превращает один тип ошибки в другой — его часто используют вместе с ?. (Трейты подробно разберём в 8-м уроке.)

Rust
use std::fmt;

#[derive(Debug)]
enum AgeError {
    NotANumber,
    TooOld(u32),
}

impl fmt::Display for AgeError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AgeError::NotANumber => write!(f, "age must be a number"),
            AgeError::TooOld(n) => write!(f, "{n} is too old"),
        }
    }
}

fn parse_age(s: &str) -> Result<u32, AgeError> {
    let age: u32 = s.parse().map_err(|_| AgeError::NotANumber)?;
    if age > 150 {
        return Err(AgeError::TooOld(age));
    }
    Ok(age)
}

fn main() {
    for s in ["15", "abc", "200"] {
        match parse_age(s) {
            Ok(age) => println!("ok: {age}"),
            Err(e) => println!("error: {e} / {e:?}"),
        }
    }
}

Ожидаемый результат

ok: 15
error: age must be a number / NotANumber
error: 200 is too old / TooOld(200)
{e} использует нашу реализацию Display, а {e:?} — текст, сгенерированный #[derive(Debug)]. |_| — короткая функция, игнорирующая свой параметр (замыкание, 7-й урок).

Запомни

  • panic! останавливает программу при баге; ожидаемые ошибки возвращаются как Result<T, E>.
  • Result содержит либо Ok(значение), либо Err(ошибка) и обрабатывается через match.
  • unwrap и expect паникуют при Err; в рабочем коде предпочитай ?, match или unwrap_or.
  • ? извлекает значение из Ok, а Err сразу возвращает вызывающему; работает только в функциях, возвращающих Result или Option.
  • Для собственного типа ошибки напиши enum, реализуй для него Display и преобразуй ошибки через map_err.
Заметил ошибку или неточность в уроке?

Проверь себя

Вопросов: 10. Каждый правильный ответ приносит XP.

Вопрос 1 / 10

Вопрос 1 / 10. Что делает оператор ?, если результат — Err?