RustでサードパーティAPIを呼び出すCLIツールの作成ガイド

Rustは、その安全性、パフォーマンス、並行処理の強さから、さまざまなシステムプログラミングに適した言語として注目されています。本記事では、Rustを使用してサードパーティAPIを呼び出すCLIツールを作成する手順を解説します。例えば、reqwestクレートを使えばHTTPリクエストを簡単に扱えるため、外部サービスとのデータ通信が容易に実現できます。CLIツールは、効率的なタスク処理や自動化に非常に役立ちます。APIのデータを取得して分析したり、定期的なタスクをコマンドラインから実行したいときに、RustでのCLIツール作成は強力な選択肢となるでしょう。本記事を通して、Rustの基本的なCLIツールの構造や、非同期処理、エラー処理、クレートの活用方法について学びましょう。

RustでCLIツールを作成する基本概念

RustでCLIツールを作成するには、いくつかの基本概念を理解しておく必要があります。CLIツール（コマンドラインインターフェースツール）は、テキストベースの操作を提供し、効率的にタスクを実行できるプログラムです。Rustはシステムプログラミング言語として優れており、CLIツールの開発に適しています。

RustのCLIツールの特徴

パフォーマンス：RustはC/C++に匹敵する高速な処理が可能です。
安全性：所有権と型システムによりメモリ安全性が保証されます。
並行処理：非同期処理や並列処理を効率的に扱えます。
エコシステム：clap、structopt、reqwestなど、多くの便利なクレートが存在します。

CLIツールの基本的な構成

CLIツールは一般的に以下のような構成で作成されます：

引数処理：ユーザーからの入力を解析します。
ロジックの実装：API呼び出しやデータ処理のロジックを記述します。
エラー処理：予期しないエラーに対する処理を行います。
出力：結果をコマンドラインに出力します。

CLIツール開発に必要なクレート

CLIツールを作成する際に便利なクレートには次のものがあります：

clap：コマンドライン引数を解析するためのクレート。
reqwest：HTTPリクエストを扱うためのクレート。
serde：JSONデータのシリアライズ・デシリアライズを行うクレート。

これらの基本概念を押さえて、RustでのCLIツール開発を効率的に進めましょう。

必要なクレートと依存関係の設定

RustでサードパーティAPIを呼び出すCLIツールを作成するには、いくつかのクレートを利用する必要があります。これらのクレートは、Cargo.tomlファイルで依存関係として指定します。

Cargoプロジェクトの作成

まず、新しいCargoプロジェクトを作成します。

cargo new api_cli_tool
cd api_cli_tool

Cargo.tomlへの依存関係の追加

次に、API呼び出しやCLI引数処理のために必要なクレートをCargo.tomlに追加します。

[dependencies]
# HTTPリクエスト用のクレート
reqwest = { version = "0.11", features = ["blocking", "json"] }

# CLI引数の処理用クレート
clap = { version = "4.0", features = ["derive"] }

# JSONのシリアライズ・デシリアライズ用
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

# 非同期処理用
tokio = { version = "1", features = ["full"] }

各クレートの役割

reqwest

HTTPリクエストを送信するためのクレート。GETやPOSTリクエスト、JSONの送受信をサポートしています。
blocking機能を追加すると同期処理が可能になります。

clap

CLI引数を簡単に処理できるクレート。マクロを使って引数の解析ロジックを簡潔に書けます。

serde / serde_json

JSONデータのシリアライズやデシリアライズに使用します。APIレスポンスの解析に役立ちます。

tokio

非同期処理をサポートするランタイムです。HTTPリクエストを非同期で実行する際に必要です。

依存関係のインストール

依存関係をCargo.tomlに追加したら、以下のコマンドでクレートをインストールします。

cargo build

これでCLIツールを作成する準備が整いました。次に、reqwestを使ったHTTPリクエストの基礎を見ていきましょう。

`reqwest`クレートを使ったHTTPリクエストの基礎

RustでサードパーティAPIを呼び出すには、HTTPリクエストを行う必要があります。reqwestクレートを使用することで、簡単にHTTPリクエストを処理できます。ここでは、GETおよびPOSTリクエストの基本的な使い方を解説します。

GETリクエストの実装

APIからデータを取得するためには、GETリクエストを使用します。以下は基本的なGETリクエストの例です。

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let url = "https://jsonplaceholder.typicode.com/posts/1";
    let response = reqwest::get(url).await?.text().await?;
    println!("Response: {}", response);
    Ok(())
}

コードの解説

reqwest::get(url)：指定したURLに対してGETリクエストを送信します。
.await?：非同期処理が完了するのを待ち、エラーがあればそのまま返します。
.text().await?：レスポンスのボディをテキストとして取得します。

POSTリクエストの実装

データを送信する場合は、POSTリクエストを使用します。以下はPOSTリクエストの例です。

use reqwest::Client;
use serde::Serialize;
use std::error::Error;

#[derive(Serialize)]
struct PostData {
    title: String,
    body: String,
    userId: u32,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let url = "https://jsonplaceholder.typicode.com/posts";
    let new_post = PostData {
        title: String::from("Rust and reqwest"),
        body: String::from("This is a sample post created with Rust."),
        userId: 1,
    };

    let client = Client::new();
    let response = client.post(url).json(&new_post).send().await?;
    let response_text = response.text().await?;

    println!("Response: {}", response_text);
    Ok(())
}

コードの解説

Client::new()：HTTPクライアントのインスタンスを生成します。
.post(url)：指定したURLにPOSTリクエストを送信します。
.json(&new_post)：リクエストのボディにJSONデータを設定します。
.send().await?：リクエストを送信し、レスポンスを待ちます。

エラー処理

HTTPリクエストではエラーが発生することがあります。Result型を使用してエラー処理を行いましょう。

let result = reqwest::get(url).await;

match result {
    Ok(response) => println!("Success: {:?}", response),
    Err(e) => eprintln!("Error: {}", e),
}

まとめ

reqwestを使えば、GETおよびPOSTリクエストを簡単に実装できます。非同期処理に対応しているため、大量のリクエストを効率よく処理できます。次は、CLIツールでのコマンドライン引数の処理方法を解説します。

コマンドライン引数の処理方法

RustのCLIツールでユーザーからの入力を受け取るには、clapクレートが便利です。clapは直感的なインターフェースとマクロによって、コマンドライン引数の処理を簡単に行えます。

依存関係の追加

Cargo.tomlにclapクレートを追加します。

[dependencies]
clap = { version = "4.0", features = ["derive"] }

基本的なCLI引数の処理

clapを使って引数を定義し、解析するサンプルコードです。

use clap::Parser;

/// シンプルなCLIツールのサンプル
#[derive(Parser)]
#[command(name = "api_cli_tool", version = "1.0", about = "APIを呼び出すCLIツール")]
struct Cli {
    /// APIのURL
    #[arg(short, long)]
    url: String,

    /// リクエストメソッド (GETまたはPOST)
    #[arg(short, long, default_value = "GET")]
    method: String,

    /// APIに送信するデータ (POSTリクエスト用)
    #[arg(short, long)]
    data: Option<String>,
}

fn main() {
    let args = Cli::parse();

    println!("URL: {}", args.url);
    println!("Method: {}", args.method);
    if let Some(data) = args.data {
        println!("Data: {}", data);
    }
}

コードの解説

#[derive(Parser)]

clapのマクロで、引数の定義を自動的にパースするための構造体を生成します。

引数フィールドの定義

url：APIのURLを指定する必須引数。-uまたは--urlで指定できます。
method：リクエストメソッド。デフォルトはGETです。-mまたは--methodで指定できます。
data：POSTリクエストで送信するデータ。オプション引数です。

Cli::parse()

コマンドライン引数を解析し、構造体に格納します。

実行例

以下のようにCLIツールを実行できます。

GETリクエストの場合：

cargo run -- --url https://jsonplaceholder.typicode.com/posts/1 --method GET

POSTリクエストの場合：

cargo run -- --url https://jsonplaceholder.typicode.com/posts --method POST --data '{"title": "Rust CLI", "body": "Test", "userId": 1}'

エラー処理とヘルプ表示

clapはデフォルトでエラー処理やヘルプ表示を提供します。引数が正しくない場合、以下のようなメッセージが表示されます。

cargo run -- --help

出力例：

Usage: api_cli_tool --url <URL> [--method <METHOD>] [--data <DATA>]

Options:
  -u, --url <URL>         APIのURL
  -m, --method <METHOD>   リクエストメソッド (GETまたはPOST) [default: GET]
  -d, --data <DATA>       APIに送信するデータ (POSTリクエスト用)
  -h, --help              Print help
  -V, --version           Print version

まとめ

clapクレートを使うことで、RustのCLIツールで柔軟にコマンドライン引数を処理できます。次は、APIエラー処理とレスポンスの解析について解説します。

APIエラー処理とレスポンスの解析

CLIツールでAPIを呼び出す際、エラー処理やレスポンスの解析は重要です。エラーが適切に処理されていないと、ユーザーにとって使いづらいツールになってしまいます。ここでは、reqwestを使ったエラー処理とレスポンス解析の方法を解説します。

エラー処理の基本

API呼び出しには、ネットワークエラーやレスポンスエラーが発生する可能性があります。reqwestではResult型を使ってエラー処理を行います。

以下は、GETリクエストに対する基本的なエラー処理の例です。

use reqwest::Error;
use std::process;

#[tokio::main]
async fn main() {
    let url = "https://jsonplaceholder.typicode.com/posts/1";

    match fetch_data(url).await {
        Ok(response) => println!("Response: {}", response),
        Err(e) => {
            eprintln!("Error: {}", e);
            process::exit(1);
        }
    }
}

async fn fetch_data(url: &str) -> Result<String, Error> {
    let response = reqwest::get(url).await?.text().await?;
    Ok(response)
}

コードの解説

fetch_data(url)：指定されたURLにGETリクエストを送り、結果をResult型で返します。
match：成功時はレスポンスを表示し、エラー時はエラーメッセージを表示して終了します。
process::exit(1)：エラー発生時にプログラムを終了します。

HTTPステータスコードによるエラー処理

APIのレスポンスが200以外のステータスコードの場合、エラーとして処理することが一般的です。

use reqwest::{Error, Response};
use std::process;

#[tokio::main]
async fn main() {
    let url = "https://jsonplaceholder.typicode.com/posts/invalid";

    match fetch_data(url).await {
        Ok(response) => println!("Response: {}", response),
        Err(e) => {
            eprintln!("HTTP Request Failed: {}", e);
            process::exit(1);
        }
    }
}

async fn fetch_data(url: &str) -> Result<String, Error> {
    let response: Response = reqwest::get(url).await?;

    if response.status().is_success() {
        let text = response.text().await?;
        Ok(text)
    } else {
        Err(reqwest::Error::new(
            reqwest::StatusCode::BAD_REQUEST,
            "Request failed with non-200 status code",
        ))
    }
}

コードの解説

response.status().is_success()：HTTPステータスコードが成功（200番台）かどうかを判定します。
エラーの場合、カスタムエラーを返しています。

JSONレスポンスの解析

APIのレスポンスがJSON形式の場合、serdeを使ってRustの構造体にデシリアライズできます。

use reqwest;
use serde::Deserialize;
use std::error::Error;

#[derive(Deserialize, Debug)]
struct Post {
    userId: u32,
    id: u32,
    title: String,
    body: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let url = "https://jsonplaceholder.typicode.com/posts/1";
    let post: Post = reqwest::get(url).await?.json().await?;

    println!("Title: {}", post.title);
    println!("Body: {}", post.body);
    Ok(())
}

コードの解説

#[derive(Deserialize, Debug)]：構造体Postにデシリアライズ機能を追加しています。
.json().await?：レスポンスをJSONとしてデシリアライズします。

まとめ

エラー処理とレスポンス解析は、CLIツールを信頼性の高いものにするために重要です。適切なエラーハンドリングとデータ解析によって、ユーザーにとって使いやすいツールを提供できます。次は非同期処理の実装方法について解説します。

非同期処理の実装方法

RustのCLIツールでAPIを呼び出す際、非同期処理を活用することで効率的にリクエストを処理できます。Rustの非同期処理はasync/await構文とtokioランタイムを組み合わせて実装します。

非同期処理の基本

Rustの非同期関数はasync fnで定義し、awaitで非同期タスクの完了を待ちます。

以下は、reqwestとtokioを使った非同期GETリクエストの例です。

use reqwest::Error;
use tokio;

#[tokio::main]
async fn main() -> Result<(), Error> {
    let url = "https://jsonplaceholder.typicode.com/posts/1";
    let response = fetch_data(url).await?;
    println!("Response: {}", response);
    Ok(())
}

async fn fetch_data(url: &str) -> Result<String, Error> {
    let response = reqwest::get(url).await?.text().await?;
    Ok(response)
}

コードの解説

#[tokio::main]：tokioランタイムで非同期関数mainを実行します。
async fn：非同期関数を定義します。
.await：非同期タスクが完了するのを待ちます。

複数のリクエストを並行処理する

複数のAPIリクエストを効率よく処理するには、非同期タスクを並行して実行します。以下は複数のURLに対して並行してリクエストを送る例です。

use reqwest::Error;
use tokio;

#[tokio::main]
async fn main() -> Result<(), Error> {
    let urls = vec![
        "https://jsonplaceholder.typicode.com/posts/1",
        "https://jsonplaceholder.typicode.com/posts/2",
        "https://jsonplaceholder.typicode.com/posts/3",
    ];

    let handles: Vec<_> = urls.iter().map(|&url| tokio::spawn(fetch_data(url))).collect();

    for handle in handles {
        match handle.await {
            Ok(Ok(response)) => println!("Response: {}", response),
            Ok(Err(e)) => eprintln!("Request Error: {}", e),
            Err(e) => eprintln!("Task Error: {}", e),
        }
    }

    Ok(())
}

async fn fetch_data(url: &str) -> Result<String, Error> {
    let response = reqwest::get(url).await?.text().await?;
    Ok(response)
}

コードの解説

tokio::spawn：非同期タスクを並行して実行します。
handles：非同期タスクのハンドルを収集します。
handle.await：タスクの完了を待ち、結果を処理します。

タイムアウト処理

APIの応答が遅い場合に備えて、タイムアウトを設定することが重要です。tokio::time::timeoutを使ってタイムアウトを実装できます。

use reqwest::Error;
use tokio::{self, time::{timeout, Duration}};

#[tokio::main]
async fn main() -> Result<(), Error> {
    let url = "https://jsonplaceholder.typicode.com/posts/1";

    match timeout(Duration::from_secs(5), fetch_data(url)).await {
        Ok(Ok(response)) => println!("Response: {}", response),
        Ok(Err(e)) => eprintln!("Request Error: {}", e),
        Err(_) => eprintln!("Timeout Error: Request took too long"),
    }

    Ok(())
}

async fn fetch_data(url: &str) -> Result<String, Error> {
    let response = reqwest::get(url).await?.text().await?;
    Ok(response)
}

コードの解説

timeout(Duration::from_secs(5), fetch_data(url))：5秒のタイムアウトを設定します。
タイムアウト発生時：Err(_)でタイムアウトエラーを処理します。

まとめ

Rustの非同期処理は、複数のAPIリクエストや時間のかかる処理を効率的に扱うために有用です。tokioとreqwestを活用して、並行処理やタイムアウト処理を適切に実装しましょう。次は、実用的なCLIツールのサンプルコードについて解説します。

実用的なCLIツールのサンプルコード

ここでは、Rustを使用してサードパーティAPIを呼び出すCLIツールの実用的なサンプルコードを紹介します。このツールでは、clapでコマンドライン引数を処理し、reqwestでAPIリクエストを送信し、JSONレスポンスを解析して表示します。

サンプルツールの概要

このCLIツールは、指定したURLに対してGETリクエストまたはPOSTリクエストを行い、結果をJSONとして表示します。ユーザーは以下のオプションを指定できます：

URL：リクエスト先のAPIエンドポイント
リクエストメソッド：GETまたはPOST
データ：POSTリクエスト時に送信するJSONデータ

必要なクレート

Cargo.tomlに以下の依存関係を追加します。

[dependencies]
reqwest = { version = "0.11", features = ["json"] }
clap = { version = "4.0", features = ["derive"] }
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

サンプルコード

use clap::Parser;
use reqwest::Client;
use serde::Deserialize;
use std::error::Error;

/// CLIツールの引数を定義
#[derive(Parser)]
#[command(name = "api_cli_tool", version = "1.0", about = "APIを呼び出すCLIツール")]
struct Cli {
    /// APIのURL
    #[arg(short, long)]
    url: String,

    /// リクエストメソッド (GETまたはPOST)
    #[arg(short, long, default_value = "GET")]
    method: String,

    /// POSTリクエスト用のJSONデータ
    #[arg(short, long)]
    data: Option<String>,
}

/// APIレスポンス用の構造体
#[derive(Deserialize, Debug)]
struct ApiResponse {
    #[serde(flatten)]
    body: serde_json::Value,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let args = Cli::parse();
    let client = Client::new();

    match args.method.to_uppercase().as_str() {
        "GET" => {
            let response = client.get(&args.url).send().await?;
            handle_response(response).await?;
        }
        "POST" => {
            if let Some(data) = &args.data {
                let response = client.post(&args.url).body(data.clone()).send().await?;
                handle_response(response).await?;
            } else {
                eprintln!("Error: POSTリクエストにはデータが必要です。");
            }
        }
        _ => {
            eprintln!("Error: サポートされていないリクエストメソッドです。GETまたはPOSTを指定してください。");
        }
    }

    Ok(())
}

async fn handle_response(response: reqwest::Response) -> Result<(), Box<dyn Error>> {
    if response.status().is_success() {
        let json: ApiResponse = response.json().await?;
        println!("Response:\n{:#?}", json);
    } else {
        eprintln!("Error: HTTPステータスコード {}", response.status());
    }
    Ok(())
}

コードの解説

CLI引数の処理

url：リクエスト先のAPIエンドポイントを指定します。
method：リクエストメソッド（GETまたはPOST）を指定します。デフォルトはGETです。
data：POSTリクエスト用のJSONデータを指定します。

handle_response関数

APIのレスポンスを受け取り、成功した場合はJSONをパースして表示します。
エラーの場合、HTTPステータスコードを表示します。

リクエストの送信

GETリクエスト：client.get(&args.url).send().await?でGETリクエストを送信します。
POSTリクエスト：client.post(&args.url).body(data.clone()).send().await?でPOSTリクエストを送信します。

ツールの実行例

GETリクエストの実行：

cargo run -- --url https://jsonplaceholder.typicode.com/posts/1 --method GET

出力例：

Response:
ApiResponse {
    body: Object {
        "userId": Number(1),
        "id": Number(1),
        "title": String("sunt aut facere repellat provident occaecati excepturi optio reprehenderit"),
        "body": String("quia et suscipit\nsuscipit repellat nisi ut minima quas consequatur delectus")
    }
}

POSTリクエストの実行：

cargo run -- --url https://jsonplaceholder.typicode.com/posts --method POST --data '{"title": "Rust CLI", "body": "Test body", "userId": 1}'

出力例：

Response:
ApiResponse {
    body: Object {
        "id": Number(101),
        "title": String("Rust CLI"),
        "body": String("Test body"),
        "userId": Number(1)
    }
}

まとめ

このサンプルツールを通して、RustでCLIツールを作成し、reqwestでAPIを呼び出し、レスポンスを処理する方法を理解できました。次は、CLIツールのテストとデバッグ方法について解説します。

CLIツールのテストとデバッグ方法

Rustで作成したCLIツールの品質を保証するためには、適切なテストとデバッグが重要です。テストを通じてコードの動作確認を行い、デバッグを活用して問題を効率的に解決する方法を解説します。

ユニットテストの作成

CLIツールの各関数やロジックをテストするために、Rustの標準ライブラリであるcargo testを利用します。

以下は、APIレスポンスを処理する関数handle_responseのユニットテスト例です。

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

async fn handle_response(response: Response) -> Result<String, Box<dyn Error>> {
    if response.status().is_success() {
        let text = response.text().await?;
        Ok(text)
    } else {
        Err(format!("Error: HTTPステータスコード {}", response.status()).into())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use http::StatusCode;
    use reqwest::ResponseBuilderExt;
    use tokio;

    #[tokio::test]
    async fn test_handle_response_success() {
        let response = Response::builder()
            .status(StatusCode::OK)
            .body("Success Response".to_string())
            .unwrap();

        let result = handle_response(response).await;
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "Success Response");
    }

    #[tokio::test]
    async fn test_handle_response_error() {
        let response = Response::builder()
            .status(StatusCode::NOT_FOUND)
            .body("Not Found".to_string())
            .unwrap();

        let result = handle_response(response).await;
        assert!(result.is_err());
    }
}

テストコードの解説

#[cfg(test)]：テストモジュールを定義し、コンパイル時にテストコードを除外します。
#[tokio::test]：非同期関数のテストを行うためのマクロです。
assert!およびassert_eq!：テスト結果が期待通りであるかを確認します。
成功・失敗ケースのテスト：ステータスコードに応じた挙動をテストしています。

統合テストの作成

CLI全体の動作を確認する統合テストは、testsディレクトリに配置します。

ファイル構造：

my_cli_tool/
├── src/
│   └── main.rs
└── tests/
    └── integration_test.rs

tests/integration_test.rs：

use assert_cmd::Command;

#[test]
fn test_cli_get_request() {
    let mut cmd = Command::cargo_bin("api_cli_tool").unwrap();
    cmd.arg("--url").arg("https://jsonplaceholder.typicode.com/posts/1")
       .arg("--method").arg("GET");
    cmd.assert().success();
}

#[test]
fn test_cli_post_request_without_data() {
    let mut cmd = Command::cargo_bin("api_cli_tool").unwrap();
    cmd.arg("--url").arg("https://jsonplaceholder.typicode.com/posts")
       .arg("--method").arg("POST");
    cmd.assert().failure();
}

統合テストの解説

assert_cmdクレート：CLIのテストをサポートするクレートです。
Command::cargo_bin("api_cli_tool")：ビルドしたCLIツールを実行します。
cmd.arg(...)：コマンドライン引数を設定します。
cmd.assert().success()：正常終了を確認します。
cmd.assert().failure()：失敗ケースを確認します。

デバッグの方法

Rustでデバッグを行うには、以下の方法が一般的です。

1. `println!` マクロを使用する

変数の値や関数の実行順序を確認するために、println!マクロを使います。

println!("URL: {}", url);
println!("Response: {:?}", response);

2. `dbg!` マクロを使用する

dbg!マクロは変数の値とその式があるファイル名、行番号を表示します。

let response = dbg!(reqwest::get(url).await?);

3. デバッガを使用する

rust-gdbやrust-lldbなどのデバッガを利用して、ブレークポイントを設定しステップ実行を行います。

使用例：

rust-gdb target/debug/api_cli_tool

まとめ

ユニットテストで関数単位の動作確認を行い、
統合テストでCLI全体の動作確認を行い、
デバッグツールを活用して効率的に問題を解決しましょう。

次は、記事のまとめに進みます。

まとめ

本記事では、Rustを使ってサードパーティAPIを呼び出すCLIツールの作成方法を解説しました。CLIツールの基本概念から始まり、reqwestクレートを使用したHTTPリクエストの実装、clapによるコマンドライン引数の処理、非同期処理の活用方法、エラー処理、テストとデバッグ手法まで網羅しました。

Rustの高パフォーマンスと安全性を活かし、効率的かつ信頼性の高いCLIツールを作成できます。これらの知識を応用すれば、APIの自動データ取得やシステム運用タスクの効率化に役立つツールを開発できるでしょう。ぜひ、実際に手を動かしてRustでのCLIツール作成にチャレンジしてみてください！

RustでサードパーティAPIを呼び出すCLIツールの作成ガイド

RustでCLIツールを作成する基本概念

RustのCLIツールの特徴

CLIツールの基本的な構成

CLIツール開発に必要なクレート

必要なクレートと依存関係の設定

Cargoプロジェクトの作成

Cargo.tomlへの依存関係の追加

各クレートの役割

依存関係のインストール

`reqwest`クレートを使ったHTTPリクエストの基礎

GETリクエストの実装

コードの解説

POSTリクエストの実装

コードの解説

エラー処理

まとめ

コマンドライン引数の処理方法

依存関係の追加

基本的なCLI引数の処理

コードの解説

実行例

エラー処理とヘルプ表示

まとめ

APIエラー処理とレスポンスの解析

エラー処理の基本

コードの解説

HTTPステータスコードによるエラー処理

コードの解説

JSONレスポンスの解析

コードの解説

まとめ

非同期処理の実装方法

非同期処理の基本

コードの解説

複数のリクエストを並行処理する

コードの解説

タイムアウト処理

コードの解説

まとめ

実用的なCLIツールのサンプルコード

サンプルツールの概要

必要なクレート

サンプルコード

コードの解説

ツールの実行例

まとめ

CLIツールのテストとデバッグ方法

ユニットテストの作成

テストコードの解説

統合テストの作成

統合テストの解説

デバッグの方法

1. `println!` マクロを使用する

2. `dbg!` マクロを使用する

3. デバッガを使用する

まとめ

まとめ

コメント

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

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