Обработка ошибок в Rust

Rust использует уникальный механизм обработки ошибок,без исключений и без try/catch.Он делит ошибки на две категории и обрабатывает их разными способами:

  • Неисправимые ошибки(Unrecoverable): когда в логике программы возникает серьёзная проблема, используйтеpanic!макрос `panic!` для завершения программы.
  • Исправимые ошибки(Recoverable): операции могут завершиться неудачей, но их можно обработать, используяResult<T, E>перечисление `Result<T, E>`.

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

Rust Error Handling Mechanism Overview Errors in Programs Unrecoverable errors panic!("serious error") Print error message → Unwind call stack → Terminate program Examples: array out of bounds, division by zero, logic bugs → Similar to uncaught exceptions in other languages Recoverable errors Result<T, E> Ok(T) represents success, Err(E) represents failure Examples: file not found, network timeout, parsing failure → Similar to checked exceptions in other languages

1. Неисправимые ошибки: panic!

panic!Макрос `panic!` используется, чтобы указать, что программа столкнулась с серьёзной ошибкой, не позволяющей ей продолжить работу. При вызове он:

  1. Вывести сообщение об ошибке и место, где она произошла
  2. Развернуть стек вызовов и освободить ресурсы
  3. Завершить программу

Пример

fn main() {
    panic!("Произошла серьёзная ошибка");
    // Следующий код никогда не выполнится
    println!("Привет, Rust");
}

Вывод:

thread 'main' panicked at '发生了严重错误', src/main.rs:2:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

Вывод содержит две строки информации:

  • Первая строка: место возникновения паники (имя файла и номер строки) и сообщение об ошибке
  • Вторая строка: подсказка о том, как просмотреть полную трассировку стека вызовов

Просмотр трассировки стека вызовов

УстановитеRUST_BACKTRACE=1Переменная окружения `RUST_BACKTRACE`, чтобы увидеть полный стек вызовов, что помогает найти первопричину паники:

# Linux / macOS
RUST_BACKTRACE=1 cargo run

# Windows PowerShell
$env:RUST_BACKTRACE=1; cargo run

Вывод трассировки перечислит полную цепочку вызовов от места паники доmainфункция `main`. Эта информация очень полезна, когда паника возникает в глубоком вызове.

Когда использоватьpanic!:В коде есть логические ошибки (баги), которые не должны происходить, например выход за границы, разыменование нулевого указателя или нарушение неизменяемого контракта. Для предсказуемых ошибок, вызванных внешним вводом, следует использовать `Result<T, E>`.Result。


2. Восстанавливаемые ошибки: Result<T, E>

Result`Result<T, E>` — это перечисление в стандартной библиотеке Rust, используемое для представления операций, которые могут завершиться неудачей:

enum Result&lt;T, E&gt; {
    Ok(T),    // 操作成功,包含结果值
    Err(E),   // 操作失败,包含错误信息
}

Все функции в стандартной библиотеке Rust, которые могут завершиться неудачей, возвращают `Result<T, E>`.ResultНапример, открытие файла:

`File::open()` returns `Result<File, io::Error>` let f = File::open("hello.txt"); File exists Ok(file) Gets a `File` object, which can be read from and written to File does not exist Err(io::Error) Gets error information, which can be handled

2.1 Использование match для обработки Result

Пример

use std::fs::File;

fn main() {
    let f = File::open("hello.txt");

    совпадение f {
        Ok(file) => {
            println!("File opened successfully: {:?}", file);
        }
        Err(error) => {
            println!("Не удалось открыть файл: {}", error);
        }
    }
}

2.2 Использование if let для упрощённой обработки

Когда вам важен только успешный случай,if letСравнениеmatch`if let` более лаконичен:

Пример

use std::fs::File;

fn main() {
    let f = File::open("hello.txt");

    if let Ok(file) = f {
        println!("Файл успешно открыт");
        // Используйте file здесь ...
    } else {
        println!("Не удалось открыть файл");
    }
}

2.3 unwrap и expect: Быстро, но опасно

Если вы уверены, что операция не завершится ошибкой (или не хотите обрабатывать ошибки при прототипировании), вы можете использовать эти два сокращённых метода:

Метод Поведение Сообщение паники при сбое
.unwrap() При успехе возвращает значение; при сбое он напрямуюTвызывает паникуpanic! используя сообщение об ошибке по умолчанию.
.expect("msg") При успехе возвращает значение; при сбое он напрямуюTвызывает паникуpanic! используя пользовательское сообщение об ошибке (проще отлаживать).

Пример

use std::fs::File;

fn main() {
    // unwrap: при сбое вызывает панику, использует сообщение по умолчанию
    // поток 'main' запаниковал с сообщением 'вызван `Result::unwrap()` для значения `Err`: ...'
    let f1 = File::open("hello.txt").unwrap();

    // expect: при сбое вызывает панику, использует пользовательское сообщение (рекомендуется)
    // поток 'main' запаниковал с сообщением 'Failed to open config file: ...'
    let f2 = File::open("hello.txt").expect("Failed to open config file");
}

Рекомендация:В рабочем коде предпочитайте использовать `expect`expectа не `unwrap`,unwrapпотому что пользовательское сообщение об ошибке помогает быстро найти проблему при возникновении паники. Ещё лучший подход — использовать?оператор `?` для передачи ошибки вызывающему.


3. Распространение ошибок: оператор ?

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

3.1 Ручное распространение против оператора ?

Сначала посмотрите на ручное распространение — многословно, но понятно:

Пример

use std::fs::File;
use std::io::{self, Read};

// Ручное распространение ошибок (утомительно)
fn read_file_manual(path: &str) -> Result<String, io::Error> {
    let f = File::open(path);

    // Вернуть Err, если открытие не удалось
    let mut file = match f {
        Ok(file) => file,
        Err(e) => return Err(e),  // Досрочно вернуть ошибку
    };

    let mut content = String::new();

    // Вернуть Err, если чтение не удалось
    match file.read_to_string(&mut content) {
        Ok(_) => Ok(content),
        Err(e) => Err(e),
    }
}

Используя?оператор `?`, ту же логику можно упростить до:

Пример

use std::fs::File;
use std::io::{self, Read};

// Использование оператора ? (кратко)
fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;   // Автоматически возвращает Err при ошибке
    let mut content = String::new();
    file.read_to_string(&mut content)?; // Автоматически возвращает Err при ошибке
    Ok(content)
}

Вы также можете объединять вызовы в цепочку, чтобы ещё больше упростить это:

fn read_file(path: &str) -> Result&lt;String, io::Error&gt; {
    let mut content = String::new();
    File::open(path)?.read_to_string(&mut content)?;
    Ok(content)
}

?Как работает оператор `?`:

Workflow of the ? operator let val = some_operation()?; Ok or Err? Result Ok `val` = value inside `Ok` Continue executing the subsequent code Err `return Err(e)` returns early

Важное ограничение:?Оператор `?` можно использовать только в функциях, которые возвращаютResult`Result` (илиOption`Option`). Начиная с Rust 1.39,mainфункция `main` также может возвращать `Result`.Result。

3.2 Использование ? в main

По умолчанию,mainФункция `main` возвращает()`()`, поэтому `?` нельзя использовать.?Но можно заставитьmain`main` возвращать `Result`.Result:

Пример

use std::fs::File;
use std::io::{self, Read};

fn read_file(path: &str) -> Result<String, io::Error> {
    let mut content = String::new();
    File::open(path)?.read_to_string(&mut content)?;
    Ok(content)
}

// main возвращает Result, поэтому ? можно использовать в main
fn main() -> Result<(), Box<dyn std::error::Ошибка>> {
    let content = read_file("hello.txt")?;  // ? теперь также можно использовать в main
    println!("{}", content);
    ОК(())
}

4. Пользовательские типы ошибок и обработка по категориям

В реальных проектах обычно нужно, чтобы разные типы ошибок обрабатывались по-разному. Rust достигает этого с помощьюkind()метода `kind()`:

Пример

use std::fs::File;
use std::io::{self, Read};

// Обернуть чтение файла в отдельную функцию и распространять ошибки с помощью ?
fn read_text_from_file(path: &str) -> Result<String, io::Error> {
    let mut f = File::open(path)?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    ОК(s)
}

fn main() {
    match read_text_from_file("hello.txt") {
        Ok(content) => println!("Содержимое файла: "\n{}", content),
        Err(e) => {
            // Обработать разные случаи в зависимости от типа ошибки
            match e.kind() {
                io::ErrorKind::NotFound => {
                    println!("Файл не найден, проверьте путь");
                }
                io::ErrorKind::PermissionDenied => {
                    println!("Нет разрешения на чтение файла");
                }
                _ => {
                    println!("Произошла ошибка при чтении файла: {}", e);
                }
            }
        }
    }
}

Вывод (когда файл не существует):

File does not exist, please check the path.

io::ErrorKindРаспространённые варианты:

ErrorKind Значение
NotFound Файл или каталог не существует
PermissionDenied Недостаточно прав
AlreadyExists Файл уже существует (при создании)
ConnectionRefused Соединение отклонено
TimedOut Время операции истекло
InvalidInput Недопустимый параметр

5. Пользовательские типы ошибок

В проектах обычно нужно определять собственные типы ошибок для представления ошибок в бизнес-логике:

Пример

use std::fmt;
use std::num::ParseIntError;

// Определите пользовательское перечисление ошибок
#[derive(Debug)]
enum AppError {
    IoError(std::io::Error),
    ParseError(ParseIntError),
    CustomError(String),
}

// Реализуйте трейт Display для форматированного вывода
impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::IoError(e) => write!(f, "Ошибка ввода-вывода: {}", e),
            AppError::ParseError(e) => write!(f, "Ошибка разбора: {}", e),
            AppError::CustomError(msg) => write!(f, "Ошибка бизнес-логики: {}", msg),
        }
    }
}

// Реализуйте трейт From, чтобы оператор ? автоматически преобразовывал типы ошибок
impl From<std::io::Error> for AppError {
    fn from(error: std::io::Error) -> Self {
        AppError::IoError(error)
    }
}

impl From<ParseIntError> for AppError {
    fn from(error: ParseIntError) -> Self {
        AppError::ParseError(error)
    }
}

// Теперь вы можете использовать ? в одной и той же функции для обработки разных типов ошибок
fn process_config(path: &str) -> Result<i32, AppError> {
    let content = std::fs::read_to_string(path)?; // io::Error → AppError
    let value: i32 = content.trim().parse()?;      // ParseIntError → AppError

    if value < 0 {
        return Err(AppError::CustomError("Значение конфигурации не может быть отрицательным".into()));
    }

    Ok(value)
}

fn main() {
    match process_config("config.txt") {
        Ok(val) => println!("Значение конфигурации: {}", val),
        Err(e) => println!("Ошибка: {}", e),
    }
}

Рекомендуемые сторонние библиотеки:В реальных проектах вы можете использоватьthiserrorбиблиотеку, чтобы автоматически выводитьDisplayиFromреализации, значительно сокращая шаблонный код. Для кода прикладного уровня,anyhowбиблиотека предоставляет удобныеanyhow::Resultтипы, подходящие для быстрой разработки.


6. Option<T>: значение, которое может не существовать

Кроме тогоResult", в Rust также есть ещё один важный enum для обработки случая \"значение может не существовать\"—"Option<T>:

enum Option&lt;T&gt; {
    Some(T),  // 有值
    None,     // 没有值
}

Optionиспользуется для замены `null` в других языкахnull". В Rust нет `null`,"null", любое значение, которое может отсутствовать, должно быть"Option"обёрнуто в `Option`:"

Пример

fn find_user(id: u32) -> Option<String> {
    match id {
        1 => Some("Alice".to_string()),
        2 => Some("Bob".to_string()),
        _ => None, // Пользователь не существует
    }
}

fn main() {
    // Используйте match для обработки Option
    match find_user(1) {
        Some(name) => println!("Найден пользователь: {}", name),
        None => println!("Пользователь не существует"),
    }

    // Используйте if let для упрощения
    if let Some(name) = find_user(99) {
        println!("Найден пользователь: {}", name);
    } else {
        println!("Пользователь не существует");
    }

    // unwrap_or предоставляет значение по умолчанию
    let name = find_user(99).unwrap_or("Анонимный пользователь".to_string());
    println!("Имя пользователя: {}", name);  // Анонимный пользователь

    // Оператор ? также работает с Option
    let first_char = get_first_char("hello");
    println!("Первая буква: {:?}", first_char);  // Some('h')
}

fn get_first_char(s: &str) -> Option<char> {
    s.chars().next() // Возвращает Option<char>
}

OptionиResultСравнение:

Пункт сравнения Option<T> Result<T, E>
Назначение Значение может существовать или не существовать Операция может завершиться успешно или с ошибкой
Успех Some(T) Ok(T)
Failure None(нет дополнительной информации) Err(E)(содержит причину ошибки)
Типичные сценарии Поиск, необязательные поля, значения по умолчанию Файловые операции, сетевые запросы, парсинг
Преобразование ok_or(err) → Result ok() → Option

Итог

Сценарий Рекомендуемый подход Описание
Программа сталкивается с неустранимой ошибкой panic!("原因") Завершить программу для ситуаций, которые не должны происходить
Операция может завершиться ошибкой ReturnResult<T, E> Заставить вызывающий код обрабатывать ошибки
Распространять ошибки внутри функции ?operator Автоматически возвращать Err при сбое, извлекать значение при успехе
Быстрое прототипирование / тестирование .expect("原因") Паника при сбое, но с понятным сообщением об ошибке
Значение может отсутствовать Option<T> использоватьSome / NoneЗаменяет null
Обрабатывать отдельно по типу ошибки e.kind() Сопоставление конкретных вариантов ошибок
Пользовательские типы ошибок РеализоватьDisplay + From Вместе с?Реализовать автоматическое преобразование

Философия обработки ошибок в Rust:Ошибки являются частью системы типов, а не исключениями в потоке управления. Компилятор заставляет вас обрабатывать каждый возможный случай ошибки, что делает вашу программу более надёжной во время выполнения.

Другие расширения