Ты спрашиваешь у пользователя возраст, а он вводит abc. Хочешь прочитать файл, а файла нет. Это не ошибки в программе, а ожидаемые ситуации — программа должна реагировать на них, не падая. Rust требует показывать все возможные неудачи в типах, и компилятор не даёт о них забыть.
Два вида ошибок
Неисправимая ошибка означает, что в программе баг: выход за границу массива или ситуация, которая «никогда не должна случиться». Тогда Rust паникует: печатает сообщение об ошибке и останавливает поток. Ты можешь и сам вызвать panic!("сообщение"). Исправимые ошибки возвращаются через тип Result<T, E>, и их обрабатывает вызывающий код.
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
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 мы обрабатываем оба случая отдельно:
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 и другие сокращения
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).
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 stringtrim() убирает пробелы по краям. {:?} показывает внутреннее устройство ошибки, а {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-м уроке.)
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.