Rust エラー処理
Rust は独特なエラー処理メカニズムを採用しています。例外(Exception)も try/catch もありません。エラーは2種類に分けられ、異なる方法で処理されます:
- 回復不能エラー(Unrecoverable):プログラムロジックに深刻な問題がある場合、
panic!panic! マクロを使用してプログラムを終了します - 回復可能エラー(Recoverable):操作は失敗する可能性がありますが処理可能で、
Result<T, E>Result 列挙型を使用します
この設計により、開発者はコンパイル時に起こり得るエラーを処理することが強制され、実行時に漏れが見つかることはありません。
1. 回復不能エラー:panic!
panic!panic! マクロは、プログラムが継続不能な重大なエラーに遭遇したことを示すために使われます。呼び出すと:
- エラーメッセージと発生位置を表示する
- 呼び出しスタックを展開(unwind)し、リソースをクリーンアップする
- プログラムを終了する
例
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<T, E> {
Ok(T), // 操作成功,包含结果值
Err(E), // 操作失败,包含错误信息
}
Rust 標準ライブラリ内で失敗する可能性のあるすべての関数は、ResultResult を返します。例えばファイルを開く場合:
2.1 match を使って Result を処理する
例
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より簡潔になります:
例
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! |
カスタムエラーメッセージを使用します(デバッグしやすい) |
例
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::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::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<String, io::Error> {
let mut content = String::new();
File::open(path)?.read_to_string(&mut content)?;
Ok(content)
}
?`?` 演算子の動作原理:
重要な制限:
?演算子は戻り値が `Result`Result(または `Option`)Optionの関数でのみ使用できます。Rust 1.39 以降、main`main` 関数も `Result` を返すことができるようになりましたResult。
3.2 main で ? を使用する
デフォルトのmain`main` 関数は `()` を返すため、()`?` を使用できません。?しかし、`main` にmain`Result` を返させることができます。Result:
例
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::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::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<T> {
Some(T), // 有值
None, // 没有值
}
Optionこれは他の言語のnullの代替です。Rust にはnullがなく、null になり得る値はすべてOptionでラップする必要があります:
例
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) |
| 失敗 | 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 のエラー処理の哲学:エラーは型システムの一部であり、制御フローの例外ではありません。コンパイラは可能性のあるすべてのエラー状況を処理することを強制するため、プログラムは実行時により信頼性が高くなります。