питон либ луна питонлиб солнце progerlib цветок

थीम बदलें

लॉगिन रजिस्ट्रेशन
🦀 Rust

Rust में एरर हैंडलिंग और एक्सेप्शन: एक विस्तृत गाइड

पाठ 19 / 35 • पूर्ण सिद्धांत पढ़ना

Что это такое и зачем? (аналогия из реальной жизни)

Представь, что ты — капитан космического корабля. Твой корабль летит к далёкой звезде. Вдруг на приборной панели загорается красная лампочка: «Ошибка! Перегрев двигателя!». Что ты сделаешь?

Вариант первый: ты паникуешь, кричишь «Всё пропало!» и нажимаешь кнопку самоуничтожения. Корабль взрывается. Программа завершилась аварийно.

Вариант второй: ты спокойно смотришь на инструкцию. Там написано: «При перегреве — снизь скорость на 20% и включи аварийное охлаждение». Ты выполняешь эти действия, и корабль продолжает полёт. Программа обработала ошибку и продолжила работу.

В программировании ошибки и исключения — это те самые красные лампочки. Они сообщают, что что-то пошло не по плану. Файл, который мы хотели открыть, не существует. Число, которое мы пытаемся разделить, оказалось нулём. Сеть, к которой мы подключаемся, недоступна.

Обработка ошибок — это набор правил и инструментов, которые позволяют программе не «взрываться» при возникновении нештатной ситуации, а красиво и безопасно выйти из положения: сообщить пользователю, что пошло не так, попробовать другой способ действий или хотя бы сохранить данные перед завершением.

В Rust к ошибкам относятся особенно серьёзно. Язык устроен так, что игнорировать ошибки невозможно. Компилятор заставит тебя обратить на них внимание. Это не потому, что Rust «злой», а потому, что он хочет, чтобы твои программы были надёжными, как тот самый космический корабль, который долетает до звезды, несмотря на все неполадки.

В Rust нет исключений в классическом понимании (как в Python или Java). Вместо этого используются два мощных механизма: перечисление Result для восстанавливаемых ошибок и макрос panic! для невосстанавливаемых.

Теория: как это работает изнутри

Давай заглянем под капот Rust и посмотрим, как устроена обработка ошибок на уровне типов и логики.

Два мира: Result и panic!

Rust делит все ошибки на два типа:

  1. Восстанавливаемые ошибки (recoverable errors) — это ситуации, которые программа может пережить. Например, пользователь ввёл неверный пароль. Мы можем сообщить ему об этом и попросить ввести снова. Для таких ошибок используется тип Result<T, E>.
  2. Невосстанавливаемые ошибки (unrecoverable errors) — это катастрофы, после которых продолжать работу бессмысленно. Например, выход за границы массива или полное отсутствие памяти. В этом случае программа вызывает макрос panic! и аварийно завершается.

Анатомия Result

Result — это перечисление (enum), которое может быть в одном из двух состояний:

enum Result<T, E> {
    Ok(T),   // Всё хорошо, внутри лежит значение типа T
    Err(E),  // Произошла ошибка, внутри лежит описание ошибки типа E
}

Когда функция может «сломаться», она возвращает не просто значение, а Result. Тот, кто вызывает эту функцию, обязан проверить, что лежит в результате: успех (Ok) или неудача (Err).

Оператор ? — магия распространения ошибок

Представь, что у тебя есть цепочка вызовов: функция А вызывает функцию Б, которая вызывает функцию В, и каждая из них может вернуть ошибку. Писать для каждой проверку match — утомительно. Для этого в Rust есть оператор ?.

Оператор ? делает две вещи:

  • Если результат — Ok(value), то он «распаковывает» его и возвращает значение value.
  • Если результат — Err(error), то он немедленно возвращает эту ошибку из текущей функции.
Важно: оператор ? можно использовать только в функциях, которые сами возвращают Result или Option.

Паника и раскрутка стека

Когда вызывается panic!, Rust начинает «раскрутку стека» (stack unwinding). Он проходит по всем вызванным функциям в обратном порядке, чистит память (вызывает деструкторы для всех созданных объектов) и только потом завершает программу. Это дорогая операция, но она гарантирует, что утечек памяти не будет.

Можно также настроить Rust так, чтобы при панике программа просто завершалась без раскрутки стека (режим abort). Это быстрее, но может привести к утечкам ресурсов.

Синтаксис в Rust: все формы и варианты

Давай разберём все инструменты, которые Rust даёт для работы с ошибками.

1. Макрос panic!

Вызывает аварийное завершение программы с сообщением.

fn main() {
    panic!("Критическая ошибка! Корабль тонет!");
    // Программа никогда не дойдёт до этой строки
    println!("Это не выполнится");
}

2. Создание и возврат Result

Функция сама решает, когда вернуть успех, а когда — ошибку.

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        // Возвращаем ошибку с описанием
        return Err("На ноль делить нельзя!".to_string());
    }
    // Возвращаем успешный результат
    Ok(a / b)
}

3. Обработка через match

Самый явный и безопасный способ разобрать Result.

let result = divide(10.0, 2.0);
match result {
    Ok(value) => println!("Результат: {}", value),
    Err(message) => println!("Ошибка: {}", message),
}

4. Методы unwrap() и expect()

Быстрые, но опасные способы «вытащить» значение. Если внутри Err — программа запаникует.

let x = divide(10.0, 2.0).unwrap(); // Если ошибка — паника
let y = divide(10.0, 0.0).expect("Деление на ноль!"); // Своё сообщение для паники

5. Оператор ?

Самый элегантный способ пробросить ошибку наверх.

fn calculate() -> Result<f64, String> {
    let a = divide(10.0, 2.0)?; // Если ошибка — выходим из calculate
    let b = divide(a, 3.0)?;    // Если ошибка — выходим из calculate
    Ok(b)
}

6. Комбинаторы: map, and_then, or_else

Позволяют обрабатывать Result в функциональном стиле, без match.

// map: преобразует значение внутри Ok
let result = divide(10.0, 2.0).map(|x| x * 2.0); // Ok(10.0)

// and_then: цепочка операций, каждая из которых может вернуть ошибку
let result = divide(10.0, 2.0)
    .and_then(|x| divide(x, 2.0))
    .and_then(|x| divide(x, 2.0)); // Ok(1.25)

// or_else: обработка ошибки с возвратом альтернативы
let result = divide(10.0, 0.0)
    .or_else(|_| Ok(0.0)); // Ok(0.0) — подставили значение по умолчанию

7. Тип Option

Близкий родственник Result, но без информации об ошибке. Используется, когда значение может отсутствовать.

enum Option<T> {
    Some(T), // Значение есть
    None,    // Значения нет
}

fn find_user(id: u32) -> Option<String> {
    if id == 1 {
        Some("Alice".to_string())
    } else {
        None
    }
}

Сводная таблица методов Result<T, E>

Метод Что делает Когда использовать
unwrap() Возвращает T или паникует Только в прототипах или когда ошибка невозможна
expect(msg) Возвращает T или паникует с сообщением Лучше, чем unwrap, даёт понятную ошибку
unwrap_or(default) Возвращает T или значение по умолчанию Когда есть безопасная замена
unwrap_or_else(fn) Возвращает T или результат вызова функции Когда замена вычисляется динамически
is_ok() Возвращает true, если это Ok Для быстрой проверки без извлечения
is_err() Возвращает true, если это Err Для быстрой проверки без извлечения
ok() Преобразует Result в Option (Ok -> Some, Err -> None) Когда информация об ошибке не нужна
err() Преобразует Result в Option (Err -> Some, Ok -> None) Когда нужно только значение ошибки
map(fn) Применяет функцию к Ok, оставляет Err как есть Для преобразования успешного значения
map_err(fn) Применяет функцию к Err, оставляет Ok как есть Для преобразования типа ошибки
and_then(fn) Цепочка операций, возвращающих Result Для последовательных шагов с возможной ошибкой
or_else(fn) Обрабатывает ошибку, возвращая альтернативный Result Для восстановления после ошибки

Примеры кода — от простого к сложному

Пример 1: Простейшая проверка деления на ноль

// Функция, которая возвращает Result
fn safe_divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        // Если делитель равен нулю, возвращаем ошибку
        return Err("Деление на ноль запрещено!".to_string());
    }
    // Иначе возвращаем успешный результат
    Ok(a / b)
}

fn main() {
    // Вызываем функцию и обрабатываем результат
    match safe_divide(10, 2) {
        Ok(result) => println!("10 / 2 = {}", result), // Выведет: 10 / 2 = 5
        Err(error) => println!("Ошибка: {}", error),
    }

    match safe_divide(10, 0) {
        Ok(result) => println!("10 / 0 = {}", result),
        Err(error) => println!("Ошибка: {}", error), // Выведет: Ошибка: Деление на ноль запрещено!
    }
}

Пример 2: Чтение числа из строки

fn parse_number(text: &str) -> Result<i32, String> {
    // Метод parse возвращает Result, который может быть Err, если строка не число
    match text.trim().parse::<i32>() {
        Ok(num) => Ok(num),
        Err(_) => Err(format!("'{}' не является целым числом!", text)),
    }
}

fn main() {
    let inputs = vec!["42", "сто", "  100  ", "3.14"];

    for input in inputs {
        match parse_number(input) {
            Ok(num) => println!("Распарсили число: {}", num),
            Err(msg) => println!("Ошибка: {}", msg),
        }
    }
    // Вывод:
    // Распарсили число: 42
    // Ошибка: 'сто' не является целым числом!
    // Распарсили число: 100
    // Ошибка: '3.14' не является целым числом!
}

Пример 3: Использование оператора ? в цепочке

use std::num::ParseIntError;

// Функция, которая парсит два числа и складывает их
fn add_two_numbers(a: &str, b: &str) -> Result<i32, ParseIntError> {
    // Оператор ? распаковывает Ok или возвращает Err
    let num_a: i32 = a.parse()?;
    let num_b: i32 = b.parse()?;
    Ok(num_a + num_b)
}

fn main() {
    // Успешный случай
    match add_two_numbers("10", "20") {
        Ok(sum) => println!("Сумма: {}", sum), // Сумма: 30
        Err(e) => println!("Ошибка парсинга: {}", e),
    }

    // Случай с ошибкой
    match add_two_numbers("10", "abc") {
        Ok(sum) => println!("Сумма: {}", sum),
        Err(e) => println!("Ошибка парсинга: {}", e), // Ошибка парсинга: invalid digit found in string
    }
}

Пример 4: Создание своего типа ошибки

use std::fmt;

// Создаём свой тип для ошибок при работе с банковским счётом
#[derive(Debug)]
enum BankError {
    InsufficientFunds { balance: f64, amount: f64 },
    AccountNotFound(String),
    InvalidAmount(String),
}

// Реализуем вывод для нашего типа ошибки
impl fmt::Display for BankError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            BankError::InsufficientFunds { balance, amount } => {
                write!(f, "Недостаточно средств: баланс {}, запрошено {}", balance, amount)
            }
            BankError::AccountNotFound(name) => {
                write!(f, "Счёт '{}' не найден", name)
            }
            BankError::InvalidAmount(msg) => {
                write!(f, "Некорректная сумма: {}", msg)
            }
        }
    }
}

struct BankAccount {
    owner: String,
    balance: f64,
}

impl BankAccount {
    fn withdraw(&mut self, amount: f64) -> Result<f64, BankError> {
        if amount <= 0.0 {
            return Err(BankError::InvalidAmount("Сумма должна быть положительной".to_string()));
        }
        if amount > self.balance {
            return Err(BankError::InsufficientFunds {
                balance: self.balance,
                amount,
            });
        }
        self.balance -= amount;
        Ok(self.balance)
    }
}

fn main() {
    let mut account = BankAccount {
        owner: "Alice".to_string(),
        balance: 100.0,
    };

    // Пробуем снять 150
    match account.withdraw(150.0) {
        Ok(new_balance) => println!("Снято успешно. Новый баланс: {}", new_balance),
        Err(e) => println!("Ошибка: {}", e), // Ошибка: Недостаточно средств: баланс 100, запрошено 150
    }

    // Пробуем снять -50
    match account.withdraw(-50.0) {
        Ok(new_balance) => println!("Снято успешно. Новый баланс: {}", new_balance),
        Err(e) => println!("Ошибка: {}", e), // Ошибка: Некорректная сумма: Сумма должна быть положительной
    }
}

Пример 5: Работа с файлами и ?

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

// Функция читает содержимое файла и возвращает его как строку
fn read_file_contents(path: &str) -> Result<String, io::Error> {
    // Пытаемся открыть файл. Если ошибка — ? вернёт её из функции
    let mut file = File::open(path)?;

    let mut contents = String::new();
    // Пытаемся прочитать содержимое. Если ошибка — ? вернёт её
    file.read_to_string(&mut contents)?;

    Ok(contents)
}

fn main() {
    // Пробуем прочитать существующий файл
    match read_file_contents("Cargo.toml") {
        Ok(contents) => println!("Содержимое файла (первые 100 символов):
{}", &contents[..100.min(contents.len())]),
        Err(e) => println!("Не удалось прочитать файл: {}", e),
    }

    // Пробуем прочитать несуществующий файл
    match read_file_contents("nonexistent.txt") {
        Ok(contents) => println!("Содержимое: {}", contents),
        Err(e) => println!("Не удалось прочитать файл: {}", e),
        // Выведет что-то вроде: Не удалось прочитать файл: No such file or directory (os error 2)
    }
}

Пример 6: Комбинаторы map и and_then

// Функция, которая удваивает число, если оно чётное
fn double_if_even(x: i32) -> Result<i32, String> {
    if x % 2 == 0 {
        Ok(x * 2)
    } else {
        Err(format!("{} не является чётным числом", x))
    }
}

fn main() {
    // Используем map для преобразования успешного значения
    let result = double_if_even(4).map(|x| format!("Результат: {}", x));
    println!("{:?}", result); // Ok("Результат: 8")

    // Используем and_then для цепочки операций
    let chain_result = double_if_even(2)
        .and_then(|x| double_if_even(x)) // 2 -> 4 -> double_if_even(4) -> Ok(8)
        .and_then(|x| double_if_even(x)); // 8 -> 16 -> double_if_even(16) -> Ok(32)
    println!("{:?}", chain_result); // Ok(32)

    // Цепочка прерывается на ошибке
    let broken_chain = double_if_even(2)
        .and_then(|x| double_if_even(x)) // 2 -> 4 -> Ok(8)
        .and_then(|_| double_if_even(3)); // 3 нечётное -> Err
    println!("{:?}", broken_chain); // Err("3 не является чётным числом")
}

Пример 7: Обработка паники с помощью catch_unwind

use std::panic;

fn dangerous_function() {
    // Эта функция может запаниковать
    let v = vec![1, 2, 3];
    println!("{}", v[10]); // Выход за границы массива — паника!
}

fn main() {
    // catch_unwind пытается выполнить функцию и "ловит" панику
    let result = panic::catch_unwind(|| {
        dangerous_function();
    });

    match result {
        Ok(_) => println!("Функция выполнилась успешно"),
        Err(e) => {
            // Мы можем узнать причину паники
            if let Some(msg) = e.downcast_ref::<&str>() {
                println!("Поймали панику: {}", msg);
            } else {
                println!("Поймали панику неизвестного типа");
            }
        }
    }

    println!("Программа продолжает работу!");
    // Вывод:
    // Поймали панику: index out of bounds: the len is 3 but the index is 10
    // Программа продолжает работу!
}
Важно: catch_unwind — это продвинутый инструмент. Не стоит использовать его для обычной обработки ошибок. Он нужен в особых случаях, например, когда ты пишешь сервер, который не должен падать из-за ошибки в одном из запросов.

Сравнение с Python: чем похоже и чем отличается

Если ты уже знаком с Python, тебе будет проще понять Rust. Но есть важные различия, которые нужно запомнить.

Характеристика Python Rust
Основной механизм Исключения (try/except/finally) Тип Result<T, E> и panic!
Обязательность обработки Необязательно. Можно проигнорировать исключение, и оно всплывёт наверх Обязательно. Компилятор выдаст предупреждение, если проигнорировать Result
Скорость Исключения относительно медленные (создание stack trace) Result — это просто enum, работает быстро. panic! — медленный, но используется редко
Тип ошибки Любой класс, унаследованный от Exception Строгий тип E в Result. Ошибка — это значение, а не объект с stack trace
Распространение ошибки Автоматическое (исключение летит вверх по стеку) Явное (оператор ? или match)
Аналог panic! raise Exception("...") без try/except panic!("...")
Аналог try/except try: ... except: ... match result { Ok(v) => ..., Err(e) => ... }
Аналог finally finally: ... Деструкторы (Drop trait) или паттерн RAII
Создание своей ошибки class MyError(Exception): pass Создание enum или struct с реализацией Display и Debug

Главное отличие в философии

В Python считается нормальным: «попробуй сделать, если не получится — поймай исключение». Это называется LBYL (Look Before You Leap) — «посмотри перед прыжком».

В Rust подход другой: EAFP (Easier to Ask for Forgiveness than Permission) — «легче попросить прощения, чем разрешения». Но реализован он через типы. Rust говорит: «Ты знаешь, что операция может не получиться. Вот тебе Result. Обработай оба варианта явно».

В Python ты можешь забыть обернуть код в try/except, и программа упадёт в самый неподходящий момент. В Rust компилятор не даст тебе забыть. Он скажет: "Ты проигнорировал Result. Ты уверен, что это правильно?"

Типичные ошибки и подводные камни

1. Чрезмерное использование unwrap()

Самая распространённая ошибка новичков. unwrap() — это как бомба замедленного действия. Он работает, пока всё хорошо, но при первой же ошибке программа упадёт.

// ПЛОХО: любая ошибка — и программа падает
let number = "abc".parse::<i32>().unwrap(); // panic!

// ХОРОШО: обрабатываем ошибку
let number = match "abc".parse::<i32>() {
    Ok(n) => n,
    Err(e) => {
        eprintln!("Не удалось распарсить число: {}", e);
        0 // Значение по умолчанию
    }
};

2. Игнорирование предупреждений компилятора

Если ты видишь предупреждение unused Result that must be used — это не просто так. Rust предупреждает, что ты проигнорировал ошибку.

// ПЛОХО: предупреждение компилятора
File::create("test.txt");

// ХОРОШО: явно обрабатываем или игнорируем
let _ = File::create("test.txt"); // Игнорируем намеренно
File::create("test.txt").expect("Не удалось создать файл"); // Или обрабатываем

3. Путаница между Result и Option

Result — для операций, которые могут не получиться по объективной причине (нет файла, нет прав). Option — для случаев, когда значение может просто отсутствовать (первый элемент пустого списка).

// НЕПРАВИЛЬНО: используем Result там, где нужен Option
fn first_element(vec: &[i32]) -> Result<&i32, String> {
    vec.first().ok_or("Вектор пуст".to_string())
}

// ПРАВИЛЬНО: используем Option
fn first_element(vec: &[i32]) -> Option<&i32> {
    vec.first()
}

4. Потеря информации об ошибке при использовании ?

Оператор ? автоматически конвертирует ошибки с помощью трейта From. Если ты используешь ? с разными типами ошибок, они должны быть конвертируемы в возвращаемый тип.

use std::fs::File;
use std::io::Read;

// ПЛОХО: разные типы ошибок
fn read_file() -> Result<String, std::io::Error> {
    let mut file = File::open("test.txt")?; // io::Error
    let mut content = String::new();
    file.read_to_string(&mut content)?; // io::Error — ок, один тип
    Ok(content)
}

// ХОРОШО: используем Box<dyn Error> для разных типов
fn read_file_flexible() -> Result<String, Box<dyn std::error::Error>> {
    let mut file = File::open("test.txt")?; // io::Error -> Box<dyn Error>
    let mut content = String::new();
    file.read_to_string(&mut content)?; // io::Error -> Box<dyn Error>
    Ok(content)
}

5. Паника в библиотечном коде

Если ты пишешь библиотеку для других, никогда не используй panic! для обычных ошибок. Твои пользователи не ожидают, что библиотека будет падать. Всегда возвращай Result.

// ПЛОХО: библиотечная функция паникует
pub fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("Деление на ноль!");
    }
    a / b
}

// ХОРОШО: библиотечная функция возвращает Result
pub fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        return Err("Деление на ноль!".to_string());
    }
    Ok(a / b)
}

Лучшие практики и советы профессионалов

1. Используйте свои типы ошибок

Не возвращайте String в качестве ошибки. Создайте enum, который описывает все возможные ошибки в вашей программе. Это делает код самодокументируемым.

#[derive(Debug)]
pub enum ConfigError {
    FileNotFound(String),
    ParseError { line: u32, message: String },
    InvalidValue(String),
}

impl std::fmt::Display for ConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self
← पिछला OOP: Rust में एनकैप्सुलेशन और पॉलीमॉर्फिज्म: एक वि आगे → Rust में फाइलों के साथ काम करना: एक विस्तृत गाइड