MENU
  1. ホーム
  2. Rust
  3. RustでのJSON操作を徹底解説！serdeを用いた効率的なパースとシリアライズ

RustでのJSON操作を徹底解説！serdeを用いた効率的なパースとシリアライズ

Rust

JSON（JavaScript Object Notation）は、軽量で人間にも機械にも扱いやすいデータフォーマットとして、現代のソフトウェア開発において不可欠な存在です。Rustは、その高性能と堅牢性で知られ、多くの場面でJSONデータを効率的に処理するために利用されています。

RustでJSONを扱う際に欠かせないのが、強力なシリアライズ・デシリアライズライブラリであるserdeです。このライブラリは、Rustの型システムと緊密に連携し、型安全なデータ操作を可能にします。

本記事では、serdeクレートを用いたRustにおけるJSON操作を徹底解説します。基礎的なパースやシリアライズから、エラーハンドリング、ネストされたデータ構造の処理、Web APIでの活用例まで、幅広い実装例を通じてその活用方法を学びます。Rust初心者にも理解しやすいように構成されており、JSON操作を通じてRustの魅力を存分に体感できる内容となっています。

目次

`serde`クレートの概要

`serde`とは何か


serde（Serialization and Deserializationの略）は、Rustでデータのシリアライズ（構造体から文字列やバイナリ形式への変換）とデシリアライズ（文字列やバイナリ形式から構造体への変換）を効率的かつ型安全に行うためのライブラリです。Rustエコシステムの中でも非常に人気があり、多くのプロジェクトで採用されています。

主な特徴

  • 高速性: Rustのゼロコスト抽象化を活用し、高速なデータ操作が可能。
  • 型安全性: Rustの型システムと連携して、不正なデータ操作をコンパイル時に防ぐ。
  • 拡張性: JSON、YAML、MessagePackなど、さまざまなフォーマットをサポートするクレートと連携可能。
  • 簡潔な記述: アノテーション（属性）を使用することで、直感的にコードを記述できる。

インストールと基本的な使用方法


まず、serdeとそのJSONサポートライブラリであるserde_jsonをプロジェクトに追加します。

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

次に、Rustの構造体に対してserdeの属性を付与します。以下はシンプルな例です。

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
    email: String,
}

このコードは、serdeを活用してUser構造体を簡単にシリアライズやデシリアライズできるようにします。

`serde`の利点

  • 簡単に導入でき、Rust初心者でも使いやすい。
  • Rust標準の型や独自の型を柔軟にサポート。
  • パフォーマンスを重視した設計により、特に大規模データセットの操作で優れた性能を発揮。

serdeは、RustプロジェクトでJSONや他のデータフォーマットを操作する際の事実上の標準と言えます。このセクションを理解することで、以降のパースやシリアライズの解説をより深く理解できるでしょう。

JSONパースの基礎

JSONパースとは


JSONパースは、文字列として表現されたJSONデータをRustの型に変換するプロセスです。Rustではserdeとserde_jsonを使うことで、簡単かつ型安全にパースを実現できます。

基本的なパースの流れ


まずは、serde_jsonを使った基本的なパースの例を見てみましょう。

JSONデータ

以下のようなJSON文字列をパースするとします。

{
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com"
}

Rustコード

このJSONをRust構造体に変換するコードは次の通りです。

use serde::Deserialize;
use serde_json;

#[derive(Deserialize)]
struct User {
    id: u32,
    name: String,
    email: String,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let json_data = r#"
    {
        "id": 1,
        "name": "Alice",
        "email": "alice@example.com"
    }
    "#;

    // JSON文字列をパースしてUser型に変換
    let user: User = serde_json::from_str(json_data)?;

    println!("ID: {}, Name: {}, Email: {}", user.id, user.name, user.email);

    Ok(())
}

コードの解説

  1. Deserializeの導入
    構造体に#[derive(Deserialize)]を付けることで、serdeがパースを自動化します。
  2. JSON文字列の指定
    r#を使用することで、エスケープシーケンスを気にせずにJSON文字列を記述可能です。
  3. serde_json::from_strの使用
    serde_json::from_str関数を使い、文字列形式のJSONを指定したRust型に変換します。

エラー処理


パース時にJSONのフォーマットが正しくない場合や、Rustの型と一致しない場合はエラーが発生します。Result型を活用して適切にエラー処理を行いましょう。

match serde_json::from_str::<User>(json_data) {
    Ok(user) => println!("Parsed user: {:?}", user),
    Err(e) => println!("Failed to parse JSON: {}", e),
}

まとめ


serdeとserde_jsonを使えば、JSONデータをシンプルかつ型安全にRust構造体へ変換できます。次セクションでは、逆にRustのデータ構造をJSON形式に変換するシリアライズの方法について解説します。

JSONシリアライズの基本

JSONシリアライズとは


JSONシリアライズは、Rustのデータ構造を文字列形式のJSONデータに変換するプロセスです。Rustではserdeクレートを活用して、効率的かつ簡単にシリアライズを実現できます。

基本的なシリアライズの流れ


以下は、構造体をJSON形式にシリアライズする基本的な例です。

Rustコード例

use serde::Serialize;
use serde_json;

#[derive(Serialize)]
struct User {
    id: u32,
    name: String,
    email: String,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let user = User {
        id: 1,
        name: "Alice".to_string(),
        email: "alice@example.com".to_string(),
    };

    // Rustの構造体をJSON文字列にシリアライズ
    let json_data = serde_json::to_string(&user)?;

    println!("Serialized JSON: {}", json_data);

    Ok(())
}

コードの解説

  1. Serializeの導入
    構造体に#[derive(Serialize)]を付けることで、serdeがシリアライズを自動化します。
  2. serde_json::to_stringの使用
    serde_json::to_string関数を用いて、Rustの構造体をJSON文字列に変換します。
  3. エラー処理
    シリアライズが失敗した場合のエラーを適切に処理します。通常、serde_json::to_stringが失敗するのは、シリアライズ不能なデータが含まれている場合です。

シリアライズ結果


上記のコードを実行すると、以下のようなJSON文字列が出力されます。

{"id":1,"name":"Alice","email":"alice@example.com"}

整形されたJSONの出力


デフォルトではシリアライズされたJSONはコンパクト形式です。人間が読みやすい整形された形式を出力するには、to_string_prettyを使用します。

let pretty_json_data = serde_json::to_string_pretty(&user)?;
println!("Pretty JSON:\n{}", pretty_json_data);

出力結果:

{
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com"
}

まとめ


JSONシリアライズを通じて、Rust構造体を簡単にJSON形式に変換できることがわかりました。この機能は、データをファイルに保存したり、Web APIに送信する場合に非常に役立ちます。次のセクションでは、シリアライズやパース中に発生するエラーの処理方法について詳しく解説します。

エラーハンドリングの実装例

エラーハンドリングの重要性


JSONのパースやシリアライズはデータ形式や内容に依存するため、操作中にエラーが発生することがあります。RustではResult型を用いたエラーハンドリングが一般的で、これによりエラーを明示的に処理できます。

パース時のエラーハンドリング


JSONのパースでよくあるエラーは以下の通りです：

  • JSONフォーマットの不正
  • 必要なフィールドの欠落
  • 型の不一致

以下はパース時にエラーを処理するコード例です。

use serde::Deserialize;
use serde_json;

#[derive(Deserialize, Debug)]
struct User {
    id: u32,
    name: String,
    email: String,
}

fn main() {
    let invalid_json = r#"
    {
        "id": "one",
        "name": "Alice"
    }
    "#;

    match serde_json::from_str::<User>(invalid_json) {
        Ok(user) => println!("Parsed user: {:?}", user),
        Err(e) => println!("Failed to parse JSON: {}", e),
    }
}

出力例

Failed to parse JSON: invalid type: string "one", expected u32 at line 3 column 15

このように、エラー内容を具体的に知ることでデバッグや修正が容易になります。

シリアライズ時のエラーハンドリング


シリアライズエラーは、通常以下の場合に発生します：

  • シリアライズできない型を含む
  • データが予期せぬ大きさ

例として、ファイルにJSONを保存する際のエラー処理を見てみましょう。

use serde::Serialize;
use serde_json;
use std::fs::File;
use std::io::Write;

#[derive(Serialize)]
struct User {
    id: u32,
    name: String,
    email: String,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let user = User {
        id: 1,
        name: "Alice".to_string(),
        email: "alice@example.com".to_string(),
    };

    // シリアライズとファイル出力
    let json_data = serde_json::to_string(&user)?;

    let mut file = File::create("user.json")?;
    file.write_all(json_data.as_bytes())?;

    println!("User data saved successfully!");
    Ok(())
}

このコードでは、エラーが発生した場合でもResult型で適切に伝搬し、プログラムの安全性を保っています。

カスタムエラーハンドリング


独自のエラーメッセージを実装することもできます。以下はカスタムエラーメッセージを出力する例です。

fn parse_json(input: &str) -> Result<(), String> {
    match serde_json::from_str::<User>(input) {
        Ok(_) => Ok(()),
        Err(e) => Err(format!("Custom error: Failed to parse JSON - {}", e)),
    }
}

これにより、エラーメッセージをより読みやすく、必要に応じて追加情報を提供できます。

まとめ


エラーハンドリングは、信頼性の高いJSON操作に欠かせません。RustのResult型とエラーメッセージの組み合わせにより、エラーの原因を特定しやすくなります。次のセクションでは、複雑なネスト構造を持つJSONデータの操作方法について解説します。

ネストされたJSONデータの扱い方

ネストされたJSONデータの特性


ネストされたJSONデータは、オブジェクトや配列が入れ子になっている複雑な構造を持っています。このようなデータを操作するには、Rustの構造体や動的データ型を効果的に利用する必要があります。

サンプルJSONデータ

以下のようなネストされたJSONを例にします。

{
    "user": {
        "id": 1,
        "name": "Alice",
        "profile": {
            "age": 30,
            "location": "Wonderland"
        }
    }
}

ネストされたデータのRust構造体への対応


このJSONをRust構造体で扱う場合、ネストされたデータに対応するために構造体を入れ子に定義します。

use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct Profile {
    age: u32,
    location: String,
}

#[derive(Deserialize, Debug)]
struct User {
    id: u32,
    name: String,
    profile: Profile,
}

#[derive(Deserialize, Debug)]
struct Root {
    user: User,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let json_data = r#"
    {
        "user": {
            "id": 1,
            "name": "Alice",
            "profile": {
                "age": 30,
                "location": "Wonderland"
            }
        }
    }
    "#;

    // JSON文字列をパース
    let data: Root = serde_json::from_str(json_data)?;

    println!("User ID: {}", data.user.id);
    println!("Name: {}", data.user.name);
    println!("Age: {}", data.user.profile.age);
    println!("Location: {}", data.user.profile.location);

    Ok(())
}

実行結果

User ID: 1
Name: Alice
Age: 30
Location: Wonderland

ネストされた配列の操作


JSON内に配列が含まれている場合も同様に対応できます。以下は、複数のプロフィールが含まれたJSONを操作する例です。

{
    "users": [
        {
            "id": 1,
            "name": "Alice",
            "profile": {
                "age": 30,
                "location": "Wonderland"
            }
        },
        {
            "id": 2,
            "name": "Bob",
            "profile": {
                "age": 25,
                "location": "Builderland"
            }
        }
    ]
}

対応するRustコードは以下の通りです。

#[derive(Deserialize, Debug)]
struct Profile {
    age: u32,
    location: String,
}

#[derive(Deserialize, Debug)]
struct User {
    id: u32,
    name: String,
    profile: Profile,
}

#[derive(Deserialize, Debug)]
struct Root {
    users: Vec<User>,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let json_data = r#"
    {
        "users": [
            {
                "id": 1,
                "name": "Alice",
                "profile": {
                    "age": 30,
                    "location": "Wonderland"
                }
            },
            {
                "id": 2,
                "name": "Bob",
                "profile": {
                    "age": 25,
                    "location": "Builderland"
                }
            }
        ]
    }
    "#;

    let data: Root = serde_json::from_str(json_data)?;

    for user in data.users {
        println!("Name: {}, Age: {}, Location: {}", user.name, user.profile.age, user.profile.location);
    }

    Ok(())
}

実行結果

Name: Alice, Age: 30, Location: Wonderland
Name: Bob, Age: 25, Location: Builderland

ネストデータの動的操作


ネスト構造が不定の場合、serde_json::Value型を使用します。

use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let json_data = r#"
    {
        "user": {
            "id": 1,
            "name": "Alice",
            "profile": {
                "age": 30,
                "location": "Wonderland"
            }
        }
    }
    "#;

    let value: Value = serde_json::from_str(json_data)?;

    let user_name = value["user"]["name"].as_str().unwrap();
    let user_age = value["user"]["profile"]["age"].as_u64().unwrap();

    println!("Name: {}, Age: {}", user_name, user_age);

    Ok(())
}

まとめ


ネストされたJSONデータをRustで扱うには、構造体を入れ子にしたり、動的なValue型を使用する方法があります。これにより、柔軟に複雑なデータを操作できます。次のセクションでは、JSONデータの検証とバリデーションについて解説します。

JSONデータのバリデーション

JSONバリデーションの重要性


受け取るJSONデータが期待する形式や値でない場合、アプリケーションがエラーを引き起こしたり、予期しない挙動を示す可能性があります。そのため、データを使用する前にバリデーションを行い、不正なデータを除外することが重要です。

バリデーションの基本手法


RustでJSONデータのバリデーションを行うには、serdeでデシリアライズした構造体や、serde_json::Valueを活用します。以下では具体的な実装例を示します。

期待される型と値のバリデーション

以下のJSONデータを例にします。

{
    "id": 1,
    "name": "Alice",
    "email": "alice@example.com",
    "age": 30
}

Rust構造体のバリデーション

まずは、構造体にデシリアライズした後にカスタムバリデーションを行う方法です。

use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct User {
    id: u32,
    name: String,
    email: String,
    age: u32,
}

fn validate_user(user: &User) -> Result<(), String> {
    if user.age < 18 {
        return Err("Age must be 18 or older".to_string());
    }
    if !user.email.contains('@') {
        return Err("Email must contain '@'".to_string());
    }
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let json_data = r#"
    {
        "id": 1,
        "name": "Alice",
        "email": "alice@example.com",
        "age": 30
    }
    "#;

    let user: User = serde_json::from_str(json_data)?;

    match validate_user(&user) {
        Ok(_) => println!("User is valid: {:?}", user),
        Err(e) => println!("Validation error: {}", e),
    }

    Ok(())
}

実行結果

User is valid: User { id: 1, name: "Alice", email: "alice@example.com", age: 30 }

動的データのバリデーション

JSONの構造が固定されていない場合、serde_json::Valueを利用して柔軟にバリデーションを行います。

use serde_json::Value;

fn validate_json(value: &Value) -> Result<(), String> {
    if let Some(age) = value["age"].as_u64() {
        if age < 18 {
            return Err("Age must be 18 or older".to_string());
        }
    } else {
        return Err("Age field is missing or invalid".to_string());
    }

    if let Some(email) = value["email"].as_str() {
        if !email.contains('@') {
            return Err("Email must contain '@'".to_string());
        }
    } else {
        return Err("Email field is missing or invalid".to_string());
    }

    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let json_data = r#"
    {
        "id": 1,
        "name": "Alice",
        "email": "alice@example",
        "age": 16
    }
    "#;

    let value: Value = serde_json::from_str(json_data)?;

    match validate_json(&value) {
        Ok(_) => println!("JSON is valid: {}", value),
        Err(e) => println!("Validation error: {}", e),
    }

    Ok(())
}

実行結果

Validation error: Age must be 18 or older

高度なバリデーション: 外部ライブラリの活用


複雑なバリデーションロジックが必要な場合、validatorクレートなどのライブラリを利用できます。

以下はvalidatorを使用した例です。

use serde::Deserialize;
use validator::Validate;

#[derive(Deserialize, Validate, Debug)]
struct User {
    #[validate(length(min = 1))]
    name: String,
    #[validate(email)]
    email: String,
    #[validate(range(min = 18))]
    age: u32,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let json_data = r#"
    {
        "name": "Alice",
        "email": "alice@example",
        "age": 16
    }
    "#;

    let user: User = serde_json::from_str(json_data)?;

    match user.validate() {
        Ok(_) => println!("User is valid: {:?}", user),
        Err(e) => println!("Validation error: {:?}", e),
    }

    Ok(())
}

実行結果

Validation error: ValidationErrors { errors: {"email": ..., "age": ...} }

まとめ


JSONバリデーションは、信頼性の高いアプリケーションを構築するために重要です。Rustでは構造体や動的型を用いたバリデーション、さらには外部ライブラリを活用することで、柔軟かつ安全にデータを検証できます。次のセクションでは、JSONデータを活用したWeb APIの実例について解説します。

応用例: Web APIでの活用

Web APIとJSONの関係


Web APIはデータのやり取りにJSONフォーマットを使用することが一般的です。RustでWeb APIを構築・利用する際、serdeとserde_jsonを使うことで、データのパースやシリアライズを簡潔に実装できます。

以下では、reqwestライブラリを使用してJSONデータを送受信するWeb APIクライアントを作成する方法を解説します。

Web APIからのデータ取得


まずは、外部APIからJSONデータを取得してRust構造体にデシリアライズする例です。

サンプルAPIのレスポンス

以下のAPIからデータを取得すると仮定します。

GET https://jsonplaceholder.typicode.com/users/1

レスポンス:

{
    "id": 1,
    "name": "Leanne Graham",
    "username": "Bret",
    "email": "Sincere@april.biz"
}

Rustコード例

use serde::Deserialize;
use reqwest;

#[derive(Deserialize, Debug)]
struct User {
    id: u32,
    name: String,
    username: String,
    email: String,
}

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

    // HTTP GETリクエストでデータを取得
    let response = reqwest::get(url).await?;

    // レスポンスボディを構造体にデシリアライズ
    let user: User = response.json().await?;

    println!("User info: {:?}", user);

    Ok(())
}

実行結果

User info: User { id: 1, name: "Leanne Graham", username: "Bret", email: "Sincere@april.biz" }

Web APIへのデータ送信


次に、JSONデータをWeb APIに送信する例を示します。

APIエンドポイント

POST https://jsonplaceholder.typicode.com/posts

送信データ:

{
    "title": "foo",
    "body": "bar",
    "userId": 1
}

Rustコード例

use serde::Serialize;
use reqwest;

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

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

    let new_post = Post {
        title: "foo".to_string(),
        body: "bar".to_string(),
        userId: 1,
    };

    // JSONデータを送信
    let response = reqwest::Client::new()
        .post(url)
        .json(&new_post)
        .send()
        .await?;

    println!("Response: {:?}", response.text().await?);

    Ok(())
}

実行結果

サーバーが受け取ったデータを返すレスポンスが得られます。

Response: {"id":101,"title":"foo","body":"bar","userId":1}

エラーハンドリングの実装


API通信ではネットワークエラーやサーバーエラーが発生する可能性があります。これらを適切に処理することでアプリケーションの信頼性を向上させます。

use serde::Deserialize;
use reqwest;

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

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

    match reqwest::get(url).await {
        Ok(response) => match response.json::<ApiResponse>().await {
            Ok(data) => println!("Received data: {:?}", data),
            Err(err) => eprintln!("Failed to parse JSON: {}", err),
        },
        Err(err) => eprintln!("HTTP request failed: {}", err),
    }
}

実行結果（ネットワークエラーの場合）

HTTP request failed: timed out

まとめ


Rustとserdeを使用することで、Web APIからのデータ取得や送信を効率的に実現できます。リクエストやレスポンスをRust構造体に直接マッピングすることで、コードの可読性が向上し、エラーハンドリングも簡単になります。次のセクションでは、JSON操作におけるベストプラクティスと注意点について解説します。

ベストプラクティスと注意点

JSON操作におけるベストプラクティス


RustでのJSON操作を効率的かつ安全に行うためのベストプラクティスを以下に示します。

1. 明確なデータモデルを定義する


Rustの型システムを活用して、明確なデータモデルを構築することが重要です。構造体を活用することで、データの構造を明確にし、型安全な操作を実現できます。

#[derive(Serialize, Deserialize, Debug)]
struct User {
    id: u32,
    name: String,
    email: String,
}

2. 必要に応じて動的型を利用する


データ構造が動的で事前に定義できない場合は、serde_json::Valueを使用して柔軟に操作します。ただし、動的型を多用するとエラーの発見が遅れるため、必要最小限にとどめるべきです。

use serde_json::Value;

fn process_dynamic_json(data: &Value) {
    if let Some(name) = data["name"].as_str() {
        println!("Name: {}", name);
    } else {
        println!("Name field is missing or invalid");
    }
}

3. エラーハンドリングを徹底する


JSON操作では、パースやシリアライズのエラーを適切に処理することが不可欠です。RustのResult型を活用してエラーの原因を特定し、適切なエラーメッセージを提供します。

match serde_json::from_str::<User>(json_data) {
    Ok(user) => println!("Parsed user: {:?}", user),
    Err(e) => println!("Failed to parse JSON: {}", e),
}

4. データ検証を実施する


データが正しいかを確認するバリデーションを行い、不正なデータがアプリケーションに影響を与えるのを防ぎます。validatorクレートのような専用ライブラリを使用するのも有効です。

注意点

1. 型の不一致を避ける


JSONのフィールドとRust構造体の型や名前が一致しないとエラーが発生します。この問題を回避するには、構造体フィールドに#[serde(rename = "field_name")]を付けてJSONのキー名を指定します。

#[derive(Deserialize)]
struct User {
    #[serde(rename = "user_id")]
    id: u32,
    name: String,
}

2. 未使用フィールドの許容


JSONから必要なフィールドだけを抽出したい場合、#[serde(default)]や#[serde(skip_deserializing)]を使用して未使用のフィールドを無視します。

#[derive(Deserialize)]
struct User {
    id: u32,
    name: String,
    #[serde(default)]
    email: Option<String>,
}

3. パフォーマンスに注意する


大規模なJSONデータの処理では、効率的なパースとシリアライズが必要です。serdeは高速ですが、場合によってはデータ構造を簡略化したり、ストリーム処理を検討すると良いでしょう。

まとめ


Rustのserdeを使ったJSON操作は型安全性が高く、信頼性のあるアプリケーションを構築するための重要な手段です。データモデルの設計、エラーハンドリング、バリデーションを徹底することで、安全で効率的なJSON操作を実現できます。次のセクションでは、この記事全体のまとめを行います。

まとめ


本記事では、RustでのJSON操作において、serdeを活用したパースやシリアライズの実装方法を解説しました。基本的な使い方から、ネストされたデータ構造の処理、エラーハンドリング、そしてWeb APIでの応用例まで幅広く取り上げました。

特に、Rustの型システムを活用することで、安全かつ効率的にデータを操作できる点が大きな利点です。また、適切なバリデーションやエラーハンドリングを導入することで、堅牢なアプリケーションの構築が可能になります。

JSON操作は、ファイルやネットワークを通じたデータ交換において必須の技術です。本記事を通じて、RustでのJSON操作に必要な基礎から応用までのスキルを習得できたことでしょう。今後の開発でぜひ活用してください。

Rust
プログラミング JSON Rust Serde

コメント

コメントする

目次