Rust エラー処理

Rust は独特なエラー処理メカニズムを採用しています。例外(Exception)も try/catch もありません。エラーは2種類に分けられ、異なる方法で処理されます:

  • 回復不能エラー(Unrecoverable):プログラムロジックに深刻な問題がある場合、panic!panic! マクロを使用してプログラムを終了します
  • 回復可能エラー(Recoverable):操作は失敗する可能性がありますが処理可能で、Result<T, E>Result 列挙型を使用します

この設計により、開発者はコンパイル時に起こり得るエラーを処理することが強制され、実行時に漏れが見つかることはありません。

Rust エラー処理メカニズムの全体像 プログラム内のエラー 回復不能エラー panic!("严重错误") エラーメッセージを表示 → 呼び出しスタックを展開 → プログラムを終了 例:配列の範囲外アクセス、ゼロ除算、ロジックバグ → 他の言語のキャッチされない例外に似ている 回復可能エラー Result<T, E> Ok(T) は成功を表し、Err(E) は失敗を表します 例:ファイルが存在しない、ネットワークタイムアウト、解析失敗 → 他の言語のチェック例外(checked exception)に似ている

1. 回復不能エラー:panic!

panic!panic! マクロは、プログラムが継続不能な重大なエラーに遭遇したことを示すために使われます。呼び出すと:

  1. エラーメッセージと発生位置を表示する
  2. 呼び出しスタックを展開(unwind)し、リソースをクリーンアップする
  3. プログラムを終了する

例

fn main() {
    panic!("重大なエラーが発生しました");
    // 以下のコードは決して実行されません
    println!("Hello, Rust");
}

実行結果:

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

出力される2行の情報:

  • 1行目:panic の位置(ファイル名と行番号)とエラーメッセージ
  • 2行目:完全な呼び出しスタックのバックトレースを確認する方法のヒント

呼び出しスタックのバックトレース(Backtrace)を表示する

設定RUST_BACKTRACE=1環境変数を設定すると、完全な呼び出しスタックを確認でき、panic の根本原因の特定に役立ちます:

# Linux / macOS
RUST_BACKTRACE=1 cargo run

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

バックトレース出力には、panic の発生位置からmain関数に至るまでの完全な呼び出しチェーンが一覧表示されます。panic が深い呼び出し層で発生した場合、この情報は非常に役立ちます。

いつ使うかpanic!:発生すべきでない論理エラー(バグ)がコードに現れた場合、例えば配列の範囲外アクセス、NULLポインタの参照外し、不変の契約違反などです。外部入力による予測可能なエラーに対しては、使用すべきですResult。


2. 回復可能エラー:Result<T, E>

ResultRust 標準ライブラリで、失敗する可能性のある操作を表す列挙型です:

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

Rust 標準ライブラリ内で失敗する可能性のあるすべての関数は、ResultResult を返します。例えばファイルを開く場合:

File::open() は Result<File, io::Error> を返します let f = File::open("hello.txt"); ファイルが存在する場合 Ok(file) File オブジェクトが得られ、読み書きできます ファイルが存在しない場合 Err(io::Error) エラーメッセージが得られ、処理できます

2.1 match を使って Result を処理する

例

use std::fs::File;

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

    match f {
        Ok(file) => {
            println!("文件打开成功: {:?}", file);
        }
        Err(error) => {
            println!("文件打开失败: {}", error);
        }
    }
}

2.2 if let を使った簡略化処理

成功する場合だけを気にしたいときは、if let 比 matchより簡潔になります:

例

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:手軽だが危険

操作が失敗しないと確信している場合(またはプロトタイプ段階でエラー処理をしたくない場合)は、この2つの簡便なメソッドを使えます:

メソッド 動作 失敗時の panic メッセージ
.unwrap() 成功時は `T` を返し、T失敗時は直接 panic! し、panic! デフォルトのエラーメッセージを使用します
.expect("msg") 成功時は `T` を返し、T失敗時は直接 panic! し、panic! カスタムエラーメッセージを使用します(デバッグしやすい)

例

use std::fs::File;

fn main() {
    // unwrap:失敗時に panic、デフォルトのメッセージを使用
    // thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: ...'
    let f1 = File::open("hello.txt").unwrap();

    // expect:失敗時に panic、カスタムメッセージを使用(推奨)
    // thread 'main' panicked at '无法打开配置文件: ...'
    let f2 = File::open("hello.txt").expect("无法打开配置文件");
}

アドバイス:本番コードでは優先的に `expect` を使用してくださいexpect`unwrap` ではなくunwrap。カスタムエラーメッセージは panic 時に問題をすばやく特定できるからです。さらに良い方法は、?`?` 演算子を使ってエラーを呼び出し元に伝播させることです。


3. エラーの伝播:? 演算子

実際の開発では、関数はエラーに遭遇したとき、自分で処理するのではなく、エラーを伝播させて呼び出し元に渡すことがよくあります。Rust は?`?` 演算子を提供しており、この操作を簡略化できます。

3.1 手動伝播 vs ? 演算子

まずは手動伝播の書き方を見てみましょう——冗長ですが明確です:

例

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)
}

?`?` 演算子の動作原理:

? 演算子の処理フロー let val = some_operation()?; Ok か Err か? Result Ok val = Ok の中の値 後続のコードを実行し続ける Err return Err(e) で早期リターン

重要な制限:?演算子は戻り値が `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::Error>> {
    let content = read_file("hello.txt")?;  // ? は main でも使えるようになります
    println!("{}", content);
    Ok(())
}

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)?;
    Ok(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);
                }
            }
        }
    }
}

実行結果(ファイルが存在しない場合):

ファイルが存在しません。パスを確認してください。

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 trait を実装して、フォーマット出力を行う
impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::IoError(e) => write!(f, "IO エラー: {}", e),
            AppError::ParseError(e) => write!(f, "解析エラー: {}", e),
            AppError::CustomError(msg) => write!(f, "業務エラー: {}", msg),
        }
    }
}

// From trait を実装して、? 演算子でエラータイプを自動変換する
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>:値が存在しない可能性がある

に加えて、ResultRust には「値がない可能性がある」状況を処理するためのもう一つの重要な列挙型があります——Option<T>:

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

Optionこれは他の言語のnullの代替です。Rust にはnullがなく、null になり得る値はすべて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&lt;char&gt; を返す
}

OptionとResultの比較:

比較項目 Option<T> Result<T, E>
用途 値が存在するか存在しない可能性がある 操作が成功するか失敗する可能性がある
成功 Some(T) Ok(T)
失敗 None(追加情報なし) Err(E)(エラー原因を含む)
典型的なシナリオ 検索、オプショナルフィールド、デフォルト値 ファイル操作、ネットワークリクエスト、解析
変換 ok_or(err) → Result ok() → Option

まとめ

シナリオ 推奨方法 説明
プログラムが修復不可能なバグに遭遇した panic!("原因") プログラムを終了する。発生すべきでない状況に使用
操作が失敗する可能性がある を返すResult<T, E> 呼び出し元にエラー処理を強制する
関数内でエラーを伝播する ?演算子 失敗時は自動的に return Err、成功時は値を取り出す
クイックプロトタイプ / テスト .expect("原因") 失敗時は panic するが、明確なエラーメッセージがある
値が存在しない可能性がある Option<T> 用 Some / Nonenull の代替
エラータイプごとに処理する e.kind() 具体的なエラーバリアントにマッチさせる
カスタムエラータイプ を実装Display + From と組み合わせて?自動変換を実装

Rust のエラー処理の哲学:エラーは型システムの一部であり、制御フローの例外ではありません。コンパイラは可能性のあるすべてのエラー状況を処理することを強制するため、プログラムは実行時により信頼性が高くなります。

その他の拡張