Rustのエラー処理を安全に行う?演算子の使い方を徹底解説

Rustのエラー処理は、安全性と効率性を両立するために設計された特徴的なシステムです。特に、Rustではコンパイル時にエラー処理が徹底されており、プログラムが実行時にクラッシュするリスクを最小限に抑えることができます。その中でも、エラー処理を簡潔かつ読みやすくするために提供されているのが?演算子です。

?演算子を使うことで、複雑になりがちなエラーハンドリングをシンプルに記述することができます。本記事では、?演算子の使い方や適用条件、具体例、非同期処理への応用までを解説し、Rustにおけるエラー処理の理解を深めます。

Rustにおけるエラー処理の基本

Rustでは、エラー処理の手法として「Result型」と「Option型」という2つの主要な型が用意されています。これらは、安全なエラー管理を行うために設計されており、エラーや欠損値の可能性を型システムを通して明示的に扱うことができます。

`Result`型とは

Result型は、関数が成功または失敗する可能性があるときに使われます。Result型は以下の2つのバリアントを持ちます。

Ok(T): 成功した場合に値Tを返します。
Err(E): 失敗した場合にエラー値Eを返します。

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

`Option`型とは

Option型は、値が存在するか欠損しているかを示します。主に欠損値を考慮する必要がある場合に使われます。Option型には以下の2つのバリアントがあります。

Some(T): 値Tが存在する場合。
None: 値が存在しない場合。

fn find_index(vec: &[i32], value: i32) -> Option<usize> {
    for (i, &item) in vec.iter().enumerate() {
        if item == value {
            return Some(i);
        }
    }
    None
}

エラー処理における安全性

Rustのエラー処理は、次の点で安全性を確保しています：

コンパイル時の検査: エラーが正しく処理されていない場合、コンパイル時に警告やエラーが発生します。
パニック回避: unwrapやexpectのようにパニックを引き起こす関数の使用は推奨されません。
明示的なエラーハンドリング: Result型とOption型を使うことで、エラー処理がコード上で明示されます。

Rustのエラー処理は安全で堅牢なコードを書くための重要な要素です。この基礎を理解した上で、次に?演算子を使った効率的なエラー処理について学びましょう。

`?`演算子の概要と使い方

Rustにおけるエラー処理をシンプルに記述するために提供されているのが?演算子です。?演算子を使うことで、Result型やOption型の値から簡単に成功値を取り出し、エラーや欠損値が発生した場合は自動的にその場でリターンすることができます。

`?`演算子の基本的な仕組み

?演算子は、以下の2つの動作を行います。

成功時 (OkやSome): 値を取り出し、そのまま次の処理に渡します。
エラー時 (ErrやNone): その場でエラーや欠損値をリターンします。

fn read_number(input: &str) -> Result<i32, std::num::ParseIntError> {
    let num = input.parse::<i32>()?;
    Ok(num)
}

この例では、input.parse::<i32>()がResult<i32, ParseIntError>を返します。?演算子を使うことで、成功時は値をnumに代入し、エラー時はそのエラーを呼び出し元に返します。

`?`演算子と`Result`型

?演算子はResult型に対して次のように動作します：

Ok(value): valueを返します。
Err(err): 関数からerrをそのまま返します。

fn open_file(filename: &str) -> Result<String, std::io::Error> {
    let content = std::fs::read_to_string(filename)?;
    Ok(content)
}

このコードでは、ファイルの読み取りが失敗した場合、エラーがそのまま呼び出し元に伝播されます。

`?`演算子と`Option`型

?演算子はOption型に対しても使用可能です：

Some(value): valueを返します。
None: Noneをそのまま返します。

fn find_char(text: &str, target: char) -> Option<usize> {
    let position = text.find(target)?;
    Some(position)
}

この場合、文字が見つからなければNoneが返されます。

複数のエラー処理を連続して記述

?演算子を用いることで、複数のエラー処理をシンプルに連続して書けます：

fn process_file(path: &str) -> Result<usize, Box<dyn std::error::Error>> {
    let content = std::fs::read_to_string(path)?;
    let length = content.parse::<usize>()?;
    Ok(length)
}

この例では、ファイル読み込みと数値変換の両方でエラーが発生する可能性がありますが、?を使うことでコードが簡潔になります。

注意点

関数がResult型やOption型を返す場合にのみ使用可能です。
非同期関数では?の使用には特別な扱いが必要です（詳細は後述）。

次の項目では、?演算子を使用するための具体的な条件について解説します。

`?`演算子の適用条件

?演算子はRustのエラー処理をシンプルにする強力なツールですが、使うためにはいくつかの適用条件と制約があります。これらの条件を理解しておくことで、効率的かつ正確に?演算子を使うことができます。

1. 戻り値の型が`Result`または`Option`であること

?演算子は、関数の戻り値がResult型またはOption型である場合にのみ使用できます。これらの型を返さない関数では?演算子を使用できません。

fn read_number(input: &str) -> Result<i32, std::num::ParseIntError> {
    let num = input.parse::<i32>()?; // `?`はResult型を返す関数内で使用可能
    Ok(num)
}

関数の戻り値がResultやOptionでない場合、コンパイルエラーが発生します。

2. `Try`トレイトの実装が必要

?演算子は、Tryトレイトを実装している型でのみ使えます。Rust標準ライブラリでは、Result型とOption型がTryトレイトを実装しています。

Result<T, E>: 成功 (Ok) または失敗 (Err) を表す。
Option<T>: 値の存在 (Some) または欠損 (None) を表す。

これにより、エラーや欠損値が自動的に呼び出し元に伝播されます。

3. 型が一致していること

?演算子を使用する場合、関数の戻り値の型と、?を適用する値の型が一致している必要があります。

正しい例:

fn read_file() -> Result<String, std::io::Error> {
    let content = std::fs::read_to_string("file.txt")?;
    Ok(content)
}

間違った例:

fn read_file() -> Result<String, std::io::Error> {
    let content = std::fs::read_to_string("file.txt")?; // Errの型が一致しないとエラー
    Ok(content)
}

この場合、戻り値の型とエラー型が一致していないとコンパイルエラーになります。

4. `main`関数での使用制約

main関数内で?演算子を使用するには、main関数の戻り値をResult<(), E>にする必要があります。

fn main() -> Result<(), std::io::Error> {
    let content = std::fs::read_to_string("file.txt")?;
    println!("{}", content);
    Ok(())
}

5. 非同期関数 (`async`関数) での使用

非同期関数内で?演算子を使用する場合、戻り値の型も非同期コンテキストに適した型にする必要があります。

async fn fetch_data() -> Result<String, reqwest::Error> {
    let response = reqwest::get("https://example.com").await?;
    let body = response.text().await?;
    Ok(body)
}

まとめ

?演算子を使用するには、以下の条件を満たしている必要があります：

関数の戻り値がResult型またはOption型であること。
Tryトレイトが実装されている型であること。
型が一致していること。
main関数や非同期関数で適切に戻り値を設定すること。

これらの条件を理解し、適切に?演算子を活用することで、Rustのエラー処理をシンプルかつ効率的に行うことができます。

`?`演算子を使った具体例

?演算子を使うことで、Rustのエラー処理は非常にシンプルで読みやすくなります。ここでは、いくつかの具体例を通して?演算子の使い方を解説します。

ファイルを読み込む例

ファイルを読み込む際、std::fs::read_to_string関数はResult<String, std::io::Error>型を返します。?演算子を使用することで、エラー処理が簡潔になります。

use std::fs::read_to_string;

fn read_file_content(path: &str) -> Result<String, std::io::Error> {
    let content = read_to_string(path)?;
    Ok(content)
}

fn main() {
    match read_file_content("example.txt") {
        Ok(content) => println!("File content: {}", content),
        Err(e) => eprintln!("Error reading file: {}", e),
    }
}

成功時：ファイルの内容がcontentに代入され、表示されます。
失敗時：エラーがErr(e)として返され、エラーメッセージが表示されます。

文字列から数値をパースする例

文字列から数値をパースする処理でも、?演算子を使ってエラー処理を簡潔にできます。

fn parse_number(input: &str) -> Result<i32, std::num::ParseIntError> {
    let number = input.parse::<i32>()?;
    Ok(number)
}

fn main() {
    match parse_number("42") {
        Ok(num) => println!("Parsed number: {}", num),
        Err(e) => eprintln!("Error parsing number: {}", e),
    }
}

成功時：パースされた数値が表示されます。
失敗時：パースエラーがキャッチされ、エラーメッセージが表示されます。

複数のエラー処理を連鎖させる例

複数の処理でエラーが発生する可能性がある場合、?演算子を連鎖させることで、コードをシンプルに記述できます。

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

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

    let first_line = content.lines().next().ok_or(io::Error::new(
        io::ErrorKind::Other,
        "File is empty",
    ))?;

    Ok(first_line.to_string())
}

fn main() {
    match read_first_line("example.txt") {
        Ok(line) => println!("First line: {}", line),
        Err(e) => eprintln!("Error: {}", e),
    }
}

ファイルを開く：File::openでファイルを開きます。
ファイルの内容を読み込む：read_to_stringでファイル内容を文字列に読み込みます。
最初の行を取得：空のファイルならエラーを返します。

`Option`型での`?`演算子の使用例

Option型でも?演算子を使うことで、欠損値の処理がシンプルになります。

fn find_char_position(text: &str, target: char) -> Option<usize> {
    let position = text.find(target)?;
    Some(position)
}

fn main() {
    match find_char_position("hello world", 'w') {
        Some(pos) => println!("Character found at position: {}", pos),
        None => println!("Character not found"),
    }
}

成功時：'w'の位置が表示されます。
失敗時：文字が見つからない場合、Noneが返されます。

まとめ

これらの具体例から分かるように、?演算子を使用することで、エラー処理を簡潔に記述し、コードの可読性を高めることができます。エラー処理が複雑になりやすい場面でも、?演算子を活用することで、エラーパスを明確に保ちつつシンプルに書けるのがRustの強みです。

`?`演算子と`unwrap`の違い

Rustでは、エラー処理や欠損値の処理に?演算子とunwrapという2つの手法がありますが、これらは根本的に異なる性質を持っています。それぞれの特徴と使いどころを理解することで、安全で信頼性の高いコードを書くことができます。

`?`演算子の特徴

?演算子は、エラーや欠損値が発生した場合に呼び出し元へエラーを伝播する仕組みです。

戻り値がResult型またはOption型である関数で使用できます。
エラーや欠損値が発生した時点で関数からリターンします。
安全性が高く、パニックを回避できます。

使用例：

fn read_number(input: &str) -> Result<i32, std::num::ParseIntError> {
    let num = input.parse::<i32>()?; // エラーが発生すると呼び出し元に伝播する
    Ok(num)
}

fn main() {
    match read_number("42a") {
        Ok(num) => println!("Number: {}", num),
        Err(e) => eprintln!("Error: {}", e),
    }
}

エラー時：エラーが呼び出し元へ伝播し、適切に処理されます。

`unwrap`の特徴

unwrapは、成功時に値を取り出し、エラーや欠損値が発生した場合は即座にパニック（プログラムがクラッシュ）します。

デバッグ用やテスト時に便利です。
エラー処理を省略したいときに使用します。
本番環境では推奨されない方法です。

使用例：

fn read_number(input: &str) -> i32 {
    let num = input.parse::<i32>().unwrap(); // エラーが発生するとパニック
    num
}

fn main() {
    let number = read_number("42a"); // パニックが発生し、クラッシュする
    println!("Number: {}", number);
}

エラー時：プログラムがクラッシュして「panic: called Result::unwrap() on an Err value」というメッセージが表示されます。

`?`演算子と`unwrap`の比較

特徴	`?`演算子	`unwrap`
エラー処理の方法	エラーを呼び出し元に伝播する	エラー時に即座にパニックする
安全性	高い	低い（クラッシュの可能性がある）
使用シーン	本番コードや安全性が必要な場合	テストやデバッグ時
戻り値の型	`Result` または `Option`	何でも使用可能
エラーの扱い	明示的なエラーハンドリングが必要	エラー処理を省略

どちらを使うべきか

本番コードや安全性が求められる処理では、?演算子を使用するのがベストです。
テストコードや、エラーが発生しないと確信できる処理ではunwrapを使用しても問題ありません。

安全なコードの例：

fn get_config_value() -> Result<String, std::io::Error> {
    let content = std::fs::read_to_string("config.txt")?;
    Ok(content)
}

危険なコードの例：

fn get_config_value() -> String {
    std::fs::read_to_string("config.txt").unwrap() // ファイルが存在しないとクラッシュする
}

まとめ

?演算子は、安全なエラー処理を実現し、エラーを呼び出し元に伝播します。
unwrapは、エラー発生時にパニックを引き起こし、本番コードではリスクがあります。

適切に使い分けることで、Rustの安全性と効率性を最大限に活用しましょう。

`?`演算子の連鎖と処理フロー

Rustにおけるエラー処理では、複数の操作を連続して行う際に、それぞれの操作でエラーが発生する可能性があります。?演算子を使用すると、複数のエラー処理をシンプルに連鎖させることができ、コードの可読性が向上します。

エラー処理の連鎖とは

エラー処理の連鎖とは、複数の処理を順番に実行し、それぞれの処理でエラーが発生したら即座にエラーを返し、成功した場合は次の処理へ進むことを指します。

例えば、以下の3つの処理を連鎖させるケースを考えます：

ファイルを開く
ファイルの内容を読み込む
読み込んだ内容を数値に変換する

`?`演算子を使った連鎖の例

以下のコードは、ファイルの内容を読み込み、その内容をi32型の数値に変換する一連の処理です。

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

fn read_number_from_file(path: &str) -> Result<i32, Box<dyn std::error::Error>> {
    // 1. ファイルを開く
    let mut file = File::open(path)?;

    // 2. ファイルの内容を読み込む
    let mut content = String::new();
    file.read_to_string(&mut content)?;

    // 3. 内容を数値に変換する
    let number = content.trim().parse::<i32>()?;

    Ok(number)
}

fn main() {
    match read_number_from_file("number.txt") {
        Ok(num) => println!("The number is: {}", num),
        Err(e) => eprintln!("Error: {}", e),
    }
}

処理フローの解説

File::open(path)?：ファイルを開きます。失敗した場合はエラーを呼び出し元に返します。
file.read_to_string(&mut content)?：ファイルの内容を文字列に読み込みます。失敗した場合はエラーを返します。
content.trim().parse::<i32>()?：文字列をi32型の数値に変換します。変換に失敗した場合はエラーを返します。
成功した場合：最終的にOk(number)で数値が返されます。

複数の関数呼び出しでの連鎖

エラー処理が関数をまたいで連鎖する場合も、?演算子を活用できます。

fn step1() -> Result<String, &'static str> {
    Ok("42".to_string())
}

fn step2(input: &str) -> Result<i32, &'static str> {
    input.parse::<i32>().map_err(|_| "Failed to parse number")
}

fn process() -> Result<i32, &'static str> {
    let data = step1()?;
    let number = step2(&data)?;
    Ok(number)
}

fn main() {
    match process() {
        Ok(num) => println!("Number: {}", num),
        Err(e) => eprintln!("Error: {}", e),
    }
}

処理の流れ

step1()が成功すれば、文字列"42"を返します。
step2(&data)?で文字列を数値に変換します。失敗すればエラーを返します。
どちらかの関数がエラーを返せば、process()関数も即座にエラーを返します。

注意点

型の整合性
?演算子を使う場合、戻り値の型が一致している必要があります。Result型のエラー型やOption型の欠損値が適切に扱われていることを確認しましょう。
関数の戻り値がResultやOptionであること
?演算子を使う関数は、Result型またはOption型を返す必要があります。
エラーの伝播
?演算子はエラーが発生するとその時点で関数からリターンします。以降の処理は実行されません。

まとめ

?演算子を使うことで、複数のエラー処理をシンプルに連鎖させることができます。
エラーが発生した場合、即座に呼び出し元にエラーが返されます。
型の整合性や関数の戻り値に注意しながら活用することで、安全で可読性の高いコードが書けます。

エラー処理でよくある落とし穴と対策

Rustにおけるエラー処理は非常に強力ですが、?演算子を使用する際に陥りやすい落とし穴があります。これらの落とし穴を理解し、適切な対策を講じることで、安全で効率的なエラー処理が可能になります。

1. 戻り値の型が合わない

問題：?演算子を使用するには、関数の戻り値がResult型またはOption型である必要があります。戻り値が異なる型だとコンパイルエラーになります。

間違った例：

fn read_number(input: &str) -> i32 {
    let num = input.parse::<i32>()?; // エラー：戻り値がResult型ではない
    num
}

対策：戻り値をResult型に変更します。

fn read_number(input: &str) -> Result<i32, std::num::ParseIntError> {
    let num = input.parse::<i32>()?;
    Ok(num)
}

2. `Option`型と`Result`型の混同

問題：?演算子はOption型とResult型の両方に使えますが、これらを混在させるとエラーが発生します。

間違った例：

fn find_and_parse(text: &str) -> Result<i32, std::num::ParseIntError> {
    let pos = text.find('x')?; // `find`はOption型を返す
    let num = text[pos..].parse::<i32>()?;
    Ok(num)
}

対策：OptionをResultに変換するためにok_orを使います。

fn find_and_parse(text: &str) -> Result<i32, std::num::ParseIntError> {
    let pos = text.find('x').ok_or(std::num::ParseIntError::from(std::io::Error::new(std::io::ErrorKind::Other, "Character not found")))?;
    let num = text[pos..].parse::<i32>()?;
    Ok(num)
}

3. エラー型が異なる場合

問題：異なる型のエラーを?演算子で処理しようとするとコンパイルエラーが発生します。

間違った例：

use std::fs::File;
use std::io;
use std::num::ParseIntError;

fn read_and_parse_file(path: &str) -> Result<i32, io::Error> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    let num = content.trim().parse::<i32>()?; // エラー型がParseIntErrorで一致しない
    Ok(num)
}

対策：異なるエラー型を統一するためにBox<dyn std::error::Error>を使用します。

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

fn read_and_parse_file(path: &str) -> Result<i32, Box<dyn std::error::Error>> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    let num = content.trim().parse::<i32>()?;
    Ok(num)
}

4. `main`関数での`?`演算子の使用

問題：main関数で?演算子を使用するには、戻り値をResult型にする必要があります。

間違った例：

fn main() {
    let content = std::fs::read_to_string("example.txt")?; // エラー：main関数の戻り値がResult型ではない
    println!("{}", content);
}

対策：main関数の戻り値をResult<(), E>に変更します。

fn main() -> Result<(), std::io::Error> {
    let content = std::fs::read_to_string("example.txt")?;
    println!("{}", content);
    Ok(())
}

5. 非同期処理 (`async`関数) での落とし穴

問題：非同期関数で?演算子を使用するには、関数の戻り値がResult型とasyncブロックに対応している必要があります。

間違った例：

async fn fetch_data() -> String {
    let response = reqwest::get("https://example.com").await?; // エラー：戻り値がResult型ではない
    response.text().await.unwrap()
}

対策：非同期関数の戻り値をResult型に変更します。

async fn fetch_data() -> Result<String, reqwest::Error> {
    let response = reqwest::get("https://example.com").await?;
    let text = response.text().await?;
    Ok(text)
}

まとめ

戻り値の型をResultまたはOptionにする。
OptionとResultの混同に注意し、ok_orで変換する。
エラー型の不一致には、エラー型を統一する。
main関数や非同期関数で?を使うには戻り値を適切に設定する。

これらの落とし穴を避けることで、Rustのエラー処理を安全かつ効率的に行うことができます。

`?`演算子と非同期処理 (async)

Rustでは非同期処理（async）を利用することで効率的なI/O操作が可能になりますが、非同期関数内でエラー処理を行う際にも?演算子を活用できます。非同期関数での?演算子の使い方や注意点を理解することで、シンプルで効率的な非同期エラー処理が実現できます。

非同期関数における`?`演算子の基本

非同期関数（async関数）は、通常の関数とは異なり、Futureを返します。そのため、?演算子を使うには、関数の戻り値をResult型やOption型にし、非同期処理に対応したエラー型を扱う必要があります。

基本的な非同期関数の構文：

async fn example() -> Result<(), SomeErrorType> {
    // 非同期処理内で`?`を使用
    let result = some_async_function().await?;
    Ok(())
}

非同期HTTPリクエストの例

以下は、reqwestクレートを使用して非同期HTTPリクエストを行う例です。エラーが発生した場合、?演算子でエラーを呼び出し元に伝播します。

use reqwest;
use std::error::Error;

async fn fetch_data(url: &str) -> Result<String, Box<dyn Error>> {
    let response = reqwest::get(url).await?;      // 非同期リクエストでエラーが発生したら即リターン
    let body = response.text().await?;            // レスポンスボディの取得でエラーが発生したら即リターン
    Ok(body)
}

#[tokio::main]
async fn main() {
    match fetch_data("https://example.com").await {
        Ok(content) => println!("Response: {}", content),
        Err(e) => eprintln!("Error: {}", e),
    }
}

解説

reqwest::get(url).await?：非同期でHTTPリクエストを行い、エラーが発生した場合はErrを返します。
response.text().await?：レスポンスの内容をテキストとして取得し、エラーが発生したらErrを返します。
戻り値：Result<String, Box<dyn Error>>により、エラーを呼び出し元に伝播します。

非同期処理で`Option`型を扱う場合

非同期関数でOption型を扱う場合も、?演算子を使うことで欠損値の処理をシンプルにできます。

async fn find_data(text: &str, target: char) -> Option<usize> {
    let position = text.find(target)?;
    Some(position)
}

#[tokio::main]
async fn main() {
    match find_data("hello world", 'w').await {
        Some(pos) => println!("Character found at position: {}", pos),
        None => println!("Character not found"),
    }
}

解説

text.find(target)?：見つからなければNoneを返し、見つかればその位置を返します。

非同期関数内のエラー型の整合性

非同期関数内で複数の異なるエラー型が発生する場合、エラー型を統一する必要があります。Box<dyn std::error::Error>を使うと、異なるエラー型を一つの型にまとめられます。

use std::fs;
use std::error::Error;

async fn read_and_parse_file(path: &str) -> Result<i32, Box<dyn Error>> {
    let content = tokio::fs::read_to_string(path).await?;  // ファイルを非同期で読み込む
    let number = content.trim().parse::<i32>()?;           // 数値に変換
    Ok(number)
}

#[tokio::main]
async fn main() {
    match read_and_parse_file("number.txt").await {
        Ok(num) => println!("Number: {}", num),
        Err(e) => eprintln!("Error: {}", e),
    }
}

非同期エラー処理の注意点

.awaitの位置

?演算子を使うには、必ず.awaitを付けて非同期処理の結果を待ちます。

エラー型の一致

非同期関数のエラー型は、?演算子で返されるエラー型と一致する必要があります。

ランタイムが必要

非同期関数を実行するにはtokioやasync-stdなどの非同期ランタイムが必要です。

まとめ

?演算子は非同期関数でも使えるため、エラー処理を簡潔に記述できます。
非同期処理では.awaitと?を組み合わせることで、シンプルなエラーチェーンを作成できます。
エラー型の統一や非同期ランタイムの使用に注意し、効率的なエラー処理を実現しましょう。

まとめ

本記事では、Rustにおけるエラー処理を安全かつ効率的に行うための?演算子の使い方について解説しました。?演算子を使用することで、エラー処理を簡潔に記述し、コードの可読性と保守性を大幅に向上させることができます。

重要なポイントは以下の通りです：

エラー処理の基本：RustではResult型とOption型を用いて安全にエラーを扱います。
?演算子の使い方：エラーや欠損値が発生した場合に呼び出し元に自動的にエラーを伝播します。
unwrapとの違い：?は安全にエラーを処理するのに対し、unwrapはパニックを引き起こします。
非同期処理：非同期関数内でも?演算子を使ってエラーを効率的に処理できます。
よくある落とし穴：型の不一致や戻り値の型に注意し、エラー処理の落とし穴を避けましょう。

Rustの?演算子を使いこなすことで、安全で効率的なプログラムを作成できるようになります。エラー処理を適切に管理し、信頼性の高いコードを目指しましょう。

Rustのエラー処理を安全に行う?演算子の使い方を徹底解説

Rustにおけるエラー処理の基本

`Result`型とは

`Option`型とは

エラー処理における安全性

`?`演算子の概要と使い方

`?`演算子の基本的な仕組み

`?`演算子と`Result`型

`?`演算子と`Option`型

複数のエラー処理を連続して記述

注意点

`?`演算子の適用条件

1. 戻り値の型が`Result`または`Option`であること

2. `Try`トレイトの実装が必要

3. 型が一致していること

4. `main`関数での使用制約

5. 非同期関数 (`async`関数) での使用

まとめ

`?`演算子を使った具体例

ファイルを読み込む例

文字列から数値をパースする例

複数のエラー処理を連鎖させる例

`Option`型での`?`演算子の使用例

まとめ

`?`演算子と`unwrap`の違い

`?`演算子の特徴

`unwrap`の特徴

`?`演算子と`unwrap`の比較

どちらを使うべきか

まとめ

`?`演算子の連鎖と処理フロー

エラー処理の連鎖とは

`?`演算子を使った連鎖の例

処理フローの解説

複数の関数呼び出しでの連鎖

処理の流れ

注意点

まとめ

エラー処理でよくある落とし穴と対策

1. 戻り値の型が合わない

2. `Option`型と`Result`型の混同

3. エラー型が異なる場合

4. `main`関数での`?`演算子の使用

5. 非同期処理 (`async`関数) での落とし穴

まとめ

`?`演算子と非同期処理 (async)

非同期関数における`?`演算子の基本

非同期HTTPリクエストの例

解説

非同期処理で`Option`型を扱う場合

解説

非同期関数内のエラー型の整合性

非同期エラー処理の注意点

まとめ

まとめ

コメント

コメントする コメントをキャンセル

コメントするコメントをキャンセル