Rust 入門

Rust は Mozilla Research 主導で開発されたシステムプログラミング言語であり、以下のメモリ安全性、ゼロコスト抽象と恐れることのない並行性を中核となる設計目標としています。

Rust は2006年に生まれ、当初は Mozilla の従業員 Graydon Hoare の個人プロジェクトでしたが、その後2009年に Mozilla が正式にスポンサーとなり、チームを結成して開発を進めました。

Rust の設計当初の目的は、C/C++ がシステムプログラミングで長年抱えてきた痛点を解決することでした:メモリ安全性の問題(ヌルポインタ、ダングリングポインタ、バッファオーバーフロー)と並行プログラミングの複雑さ(データ競合、デッドロック)。

Rust の設計哲学は「コンパイル時にバグを撲滅する」ことです。強力な型システムと所有権の仕組みにより、メモリエラーやデータ競合をコンパイラがチェックしてくれます。実行時になってから問題を発見するのではありません。

Rust 言語のマスコットは Ferris という名前のカニで、親しみやすく可愛らしく、Rust コミュニティの友好的で包摂的な文化を象徴しています。

Rust の主要な設計目標は次のようにまとめられます:

設計目標説明
メモリ安全性(GCなし)所有権システムによりコンパイル時にメモリ安全性を保証し、ガベージコレクタを不要にする
ゼロコスト抽象高級言語の機能がコンパイル後も実行時オーバーヘッドを持たず、手書きの低レベルコードと同じ性能になる
恐れることのない並行性型システムと所有権のルールによってコンパイル時にデータ競合を防ぐ
実用性OSカーネルもWebアプリも書け、フルスタックのシナリオをカバーする
強力な型推論コンパイラがほとんどの型を自動推論し、ボイラープレートコードを減らす
豊富なツールチェーンCargo(パッケージ管理+ビルド)、rustfmt(フォーマット)、clippy(コード検査)がすぐに使える

Rust言語の発展の歴史

Rust は個人プロジェクトから、世界的に広く採用されるシステム言語になるまで、約20年にわたる発展の道のりを歩んできました。

時期バージョン/出来事説明
2006年個人プロジェクトGraydon Hoare が Rust 言語の設計を開始
2009年Mozilla がスポンサーにMozilla が Rust の開発を正式に支援し、チームを結成
2010年初公開Mozilla サミットで Rust コンパイラ(OCaml製)を初めて公開
2011年セルフホスティング完了Rust コンパイラを Rust 自身で書き直し、OCaml への依存から脱却
2015年5月Rust 1.0最初の安定版がリリースされ、言語が本番環境で正式に使えるようになった
2018年12月Rust 2018 Edition最初の Edition がリリースされ、構文とモジュールシステムが改善された(NLL借用チェッカーが導入された)
2019年非同期エコシステムが形成async/await 構文が安定し、Tokio などの非同期ランタイムが成熟
2021年Rust 財団設立AWS、Google、Huawei、Microsoft、Mozilla が共同で Rust 財団を設立
2021年10月Rust 2021 Editiondisjoint capture や IntoIterator for arrays などの改善を導入
2022年Linuxカーネルが採用Linux 6.1 で Rust サポートが正式にマージされ、Rust はカーネル開発の第二言語となった
2024年2月Rust 2024 Edition言語の一貫性と開発者体験をさらに最適化

2021年の Rust 財団の設立は画期的な出来事でした。AWS、Google、Huawei、Microsoft、Mozilla の5つのテクノロジー大手が共同で Rust の長期的な独立した発展を保証し、「単一企業による支配」へのコミュニティの懸念を払拭しました。

Rust は6週間ごとの安定版というリリースリズムを採用し、同時にEditionEdition メカニズム(約3年ごとにリリース)によって互換性のない言語変更を処理します。同じプロジェクトで異なる Edition の crate を混在させることができ、コンパイラは後方互換性を保証します。


Rust言語の中核となる特徴

Rust の特長は「安全・高効率・実用」の3つの軸で構成されています。以下では Rust の中核となる言語機能を一つずつ解説します。

所有権システム(Ownership)

所有権は Rust で最もユニークで重要な機能です。コンパイル時にメモリを管理し、ガベージコレクタや手動の malloc/free を必要としません。

所有権には3つの大きなルールがあります:

ルール説明意味
すべての値にはただ1つの所有者がいるある値は同時に1つの変数にしか所有されないdouble-free やダングリングポインタを防ぐ
所有者がスコープを離れると、値は解放される変数がスコープを離れるとき、Rust が自動的に drop を呼び出してメモリを解放する手動でのメモリ管理が不要
同時に:可変参照は1つだけ、または不変参照は複数読み書きは排他、読みと読みは共存可能コンパイル時にデータ競合を防ぐ

コード上での実感:変数を別の変数に代入すると所有権が移動(move)し、元の変数は使えなくなります。

例

fn main() {
    // s1 が文字列の所有権を取得(データはヒープに保存)
    let s1 = String::from("Hello, サンプル!");

    // 所有権が s1 から s2 に移動し、以降 s1 は無効
    let s2 = s1;

    // println!("{}", s1); // コンパイルエラー!s1 は move された
    println!("{}", s2);    // 正しい:s2 が現在の所有者

    // 基本型(スタックに格納)は Copy trait を実装しているため、move は発生しない
    let x = 42;
    let y = x;  // i32 は Copy を実装しているので、x はまだ有効
    println!("x = {}, y = {}", x, y); // どちらも使用できる

    // 不変参照:同時に複数存在できる
    let s3 = &s2; // 不変借用
    let s4 = &s2; // もう1つの不変借用、許可される
    println!("s3 = {}, s4 = {}", s3, s4);

    // 可変参照:同時に1つだけ
    let mut data = String::from("サンプル");
    let r = &mut data; // 可変借用
    r.push_str("!");   // 可変参照を通して元の値を変更する
    println!("変更後: {}", r);
    // s3 と s4 のスコープが終了したので、可変参照を作成できる
}

所有権システムは Rust の学習曲線における「急な坂」です。初心者はしばしばコンパイラと「戦います」が、一度理解すれば、コンパイラが阻止するエラーは、C/C++ では致命的な実行時バグになり得ることに気づくでしょう。

パターンマッチ(Pattern Matching)

Rust のmatch式は非常に強力で、コンパイラは網羅性チェックすべてのケースをチェックし、分岐の漏れがないことを保証します。

例

fn main() {
    // match と数値のマッチング
    let score = 85;
    match score {
        90..=100 => println!("サンプル 評価: A"), // 範囲マッチング
        60..=89  => println!("サンプル 評価: B"),
        0..=59   => println!("サンプル 評価: C"),
        _ => println!("無効なスコア"),                // ワイルドカード、残りのすべてのケースにマッチ
    }

    // match でタプルを分解
    let pair = (3, 7);
    match pair {
        (0, y) => println!("最初は 0、2 番目は {}", y),
        (x, 0) => println!("最初は {}、2 番目は 0", x),
        (x, y) => println!("2 つの値: {} と {}", x, y),
    }
}

列挙型と Option/Result

Rust の列挙型(enum)はデータを保持でき、match と組み合わせることで安全かつ表現力の高い制御フローを実現できます。

標準ライブラリのOption<T>とResult<T, E>は2つの最も中核となる列挙型であり、「null の可能性」と「エラーの可能性」をそれぞれ扱います。Rust には null も例外もありません。

例

use std::fs;

fn main() {
    // Option<T>: 値が存在する場合も存在しない場合もある(null の代替)
    let numbers = vec![10, 20, 30];
    let first = numbers.get(0);   // Option<&i32> を返す
    let missing = numbers.get(5); // Option<&i32> を返す

    match first {
        Some(&val) => println!("最初の要素: {}", val),
        None => println!("見つかりませんでした"),
    }

    // より簡潔な書き方:if let
    if let Some(&val) = missing {
        println!("見つかりました: {}", val);
    } else {
        println!(インデックス 5 は存在しません);  // この分岐に入ることを期待
    }

    // Result<T, E>: 操作は成功するか失敗する可能性がある(例外の代替)
    let content = fs::read_to_string("config.txt");
    match content {
        Ok(text) => println!("ファイルの内容: {}", text),
        Err(e) => println!("読み取り失敗: {}", e),
    }
}

Rust には null 値も try-catch 例外機構もありません。Option と Result はコンパイル時に強制的に処理されます。チェックを忘れると、コードはコンパイルを通りません。これにより、ヌルポインタ例外と未捕捉例外は根本的に排除されます。

ゼロコスト抽象

Rust の高階機能(イテレータ、クロージャ、ジェネリクス)は、コンパイル後には手書きの低レベルループと完全に等価になり、追加の実行時オーバーヘッドは発生しません。

つまり、関数型に似たスタイルでコードを書きながら、C と同じ高性能を得ることができます。

例

fn main() {
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // イテレータのチェーン呼び出し —— 高度な抽象化のように見える
    // コンパイル後は手書きの for ループと等価な機械語に展開される
    let result: Vec<i32> = data
        .iter()            // イテレータを取得
        .filter(|&x| x % 2 == 0) // 偶数をフィルタリング
        .map(|&x| x * x)         // 平方を求める
        .collect();              // Vec として収集

    println!("{:?}", result); // [4, 16, 36, 64, 100]
}

恐れることのない並行性(Fearless Concurrency)

Rust の型システムと所有権規則はコンパイル時にデータ競合を排除します。Send と Sync トレイトは、型がスレッド間で安全に受け渡しまたは共有できるかどうかを自動的にマークします。

マルチスレッドでスレッドセーフでないデータを共有しようとすると、コンパイラは直接エラーを報告します。本番実行時になって謎の並行バグが発生するのを待つ必要はありません。

例

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    // Arc(原子参照カウント)はマルチスレッド間で所有権を共有するために使う
    // Mutex は相互排他アクセスを提供する
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for i in 0..10 {
        // Arc を clone して、各スレッドが同じデータへの参照を保持する
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            // lock() で相互排他ロックを取得し、MutexGuard を返す
            let mut num = counter.lock().unwrap();
            *num += 1; // 参照外し(deref)で内部の値を変更する
            println!("スレッド {} の加算が完了、現在の値: {}", i, *num);
        });
        handles.push(handle);
    }

    // すべてのスレッドの完了を待つ
    for handle in handles {
        handle.join().unwrap();
    }

    println!("最終カウント: {}", *counter.lock().unwrap());
}

Cargo:統合的なビルドツール

Cargo は Rust 公式のパッケージマネージャ兼ビルドシステムであり、依存関係管理、コンパイル、テスト、ドキュメント生成、公開機能を統合しています。

C/C++ エコシステムで CMake/Makefile やパッケージマネージャを手動で設定する分散的な体験と比較して、Cargo は「すぐに使える」統合体験を提供します。

コマンド機能典型的なシナリオ
cargo new project新規プロジェクトの作成プロジェクトを初期化し、Cargo.toml と src/main.rs を自動生成する
cargo buildプロジェクトをコンパイル(debug モード)開発・デバッグ
cargo build --releaseプロジェクトをコンパイル(最適化モード)本番リリース、すべてのコンパイラ最適化を有効化
cargo runコンパイルして実行コードをすばやくテスト
cargo testテストを実行ユニットテスト、統合テスト、ドキュメントテスト
cargo checkコードがコンパイルできるかすばやく確認(バイナリを生成しない)IDE でのリアルタイム構文チェック
cargo doc --openドキュメントを生成して開く依存ライブラリの API ドキュメントを閲覧
cargo clippyコードスタイルチェック(lint)推奨されない書き方や潜在的な問題を発見
cargo fmtコードフォーマットコードスタイルを統一
cargo publishcrates.io に公開オープンソースライブラリを公開

cargo check は開発中に非常に便利なコマンドです。構文と型のみをチェックし、実行可能ファイルを生成しないため、cargo build よりはるかに高速です。ほとんどの IDE の Rust プラグインは、ファイル保存時に自動的に cargo check を実行します。


Rust言語の応用分野

Rust はメモリ安全性と高性能という利点により、複数の分野で急速に拡大しています。

システムプログラミングと高性能サーバーサイド

これは Rust の「本領」です。究極のパフォーマンスと高いメモリ安全性が求められるシナリオに適しています。非同期ランタイムTokioと Web フレームワークActix Web、Axum高並行シナリオで優れた性能を発揮します。

WebAssembly

Rust はWebAssembly へのコンパイルに最適な言語の一つです。そのゼロコスト抽象化と GC なしの特性により、Wasm 成果物はサイズが小さく、高性能です。

フロントエンドフレームワークYewとLeptosRust で SPA アプリケーションを書くことができます。Figma、Cloudflare Workers などは本番環境で Rust + Wasm を多用しています。

組み込みとIoT

Rust のno_stdモードは、OS のないベアメタル上での実行を可能にし、MCU、センサーなどのリソース制約のあるデバイスに適しています。

RTIC(リアルタイム割り込み駆動並行フレームワーク)とEmbassy(非同期組み込みフレームワーク)は、組み込み Rust の代表的なプロジェクトです。

CLI ツール

Rust は独立したバイナリファイルにコンパイルされ、性能が優れているため、数多くのスター CLI ツールを生み出しました:

ツール機能代替対象
ripgrep (rg)超高速コード検索grep
fd高速ファイル検索find
bat構文ハイライト付きファイル表示cat
delta構文ハイライト付き Git diffgit diff
zoxideスマートなディレクトリ移動cd
dustディスク容量分析du

ブロックチェーンとWeb3

Rust はブロックチェーン分野で重要な地位を占めています。Solanaチェーンのコアは Rust で書かれており、Sui、Aptos、Polkadot(Substrate)などの新しいパブリックチェーンもすべて Rust を主要開発言語としています。

データベースとデータ基盤

高性能データベースとデータ処理システムは Rust の強みのある分野です:TiKV(分散 KV ストア、TiDB のストレージ層)、SurrealDB、Polars(DataFrame ライブラリ)、Databend(クラウドデータウェアハウス)などはすべて Rust で構築されています。

オペレーティングシステムと基盤インフラ

Rust は Linux カーネル(6.1+)に採用され、Google は Android で Rust を使って Bluetooth と Wi-Fi スタックを書き直し、Microsoft も Windows カーネルで Rust を使って一部のコンポーネントを書き直しています。

趣味のプロジェクトとしては、Redox OSは、Rust でゼロから完全に書かれた Unix 系オペレーティングシステムです。


クイックスタート

Rust 公式は非常に便利なインストールツール rustup を提供しており、1 つのコマンドでコンパイラ、パッケージマネージャ、ドキュメントを導入できます。

Rustのインストール

# Unix/macOS
$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 验证安装
$ rustc --version
rustc 1.85.0 (4d91de4e4 2025-02-17)

$ cargo --version
cargo 1.85.0

最初のRustプログラム

Cargo を使ってプロジェクトを作成するのが最も推奨される方法で、標準的なプロジェクト構造を自動生成します。

# 创建新项目
$ cargo new hello_サンプル
     Created binary (application) `hello_サンプル` package

# 项目结构
hello_サンプル/
├── Cargo.toml     # 项目元数据和依赖配置
└── src/
    └── main.rs    # 程序入口文件

Cargo.toml はプロジェクトの設定ファイルで、Node.js の package.json に似ています:

例

[package]
name = "hello_サンプル"           # パッケージ名(必須、アンダースコアで区切る)
version = "0.1.0"               # バージョン番号(必須、セマンティックバージョニングに従う)
edition = "2024"                # Rust Edition(必須、言語の構文規則に影響)

[dependencies]
# ここでプロジェクトの依存関係を宣言します。例:
# serde = { version = "1.0", features = ["derive"] }

デフォルトで生成される main.rs には、最も単純な Hello World プログラムが含まれています:

例

// ファイルパス:src/main.rs
// Rust プログラムのエントリポイント:すべての実行可能プログラムには main 関数が必要

fn main() {
    // println! はマクロです(末尾の ! 記号に注意)
    // マクロはコンパイル時により複雑なコードに展開される
    println!("Hello, サンプル!");
    println!("Rust言語の世界へようこそ");
}
# 编译并运行
$ cargo run
   Compiling hello_サンプル v0.1.0
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.52s
     Running `target/debug/hello_サンプル`
Hello, サンプル!
欢迎来到 Rust 语言的世界

基本構文の概要

Rust の構文は、関数型言語とシステム言語の利点を取り入れています。以下では、最もよく使われる構文要素を簡単に説明します。各サンプルは、そのまま実行できる完全なプログラムです。

変数と可変性

Rust の変数デフォルトで不変(イミュータブル)。これにより開発者は、どのデータが変化するかを明示的に示す必要があり、コードの意図が明確になり、コンパイラの最適化も容易になります。

例

fn main() {
    // 不変変数(デフォルト):宣言後に再代入できない
    let name = "サンプル";
    // name = "other"; // コンパイルエラー!不変変数は再代入できない
    println!("名前: {}", name);

    // 可変変数:mut キーワードで明示的に宣言
    let mut score = 0;
    println!("初期スコア: {}", score);
    score = 100;       // 変更可能
    println!("更新後のスコア: {}", score);

    // 変数シャドーイング:let で同名の変数を再宣言
    let x = 5;
    let x = x + 1;      // 新しい変数 x が古い x を覆い隠し、値は 6
    let x = x * 2;      // 再度シャドーイングし、値は 12
    println!("x の最終値: {}", x);

    // 定数:コンパイル時に確定し、型の注釈が必須。命名は全て大文字が慣例
    const MAX_POINTS: u32 = 100_000;
    println!("最大ポイント: {}", MAX_POINTS);
}

変数シャドーイングと mut は同じものではありません。シャドーイングは let で同名の新しい変数を宣言し直すことで、型を変更できます。一方 mut は同じ変数の値の変更を許可するだけで、型は変わりません。

基本データ型

Rust は静的型付け言語であり、コンパイラはコンパイル時にすべての変数の型を把握している必要があります。

カテゴリ型例説明
符号付き整数i8, i16, i32, i64, i128, isizelet x: i32 = -42;デフォルトの整数型は i32
符号なし整数u8, u16, u32, u64, u128, usizelet y: u64 = 100;usize はインデックスと長さに使用
浮動小数点数f32, f64let pi: f64 = 3.14;デフォルトの浮動小数点型は f64
ブール値boollet ok: bool = true;true または false
文字charlet c = 'R';4バイトで、Unicode スカラー値を表す
タプル(T1, T2, ...)let t: (i32, f64) = (10, 3.14);固定長で、型は異なってもよい
配列[T; N]let a: [i32; 3] = [1, 2, 3];固定長で、型は同じ。スタックに割り当てられる
スライス&[T]let s: &[i32] = &a[..];配列または Vec への参照ビュー
動的配列Vec<T>let v: Vec<i32> = vec![1,2,3];可変長で、ヒープに割り当てられる
文字列String / &strlet s = String::from("hi");String は変更可能、&str は参照

制御フロー

Rust の制御フローには次が含まれますif、loop、while、forとmatch。このうち if と loop は式として値を返すことができます。

例

fn main() {
    let score = 75;

    // if は式であり、値を返せる(各分岐は同じ型を返す必要がある)
    let grade = if score >= 90 {
        "A"
    } else if score >= 60 {
        "B"
    } else {
        "C"
    };
    println!("サンプル 評価: {}", grade);

    // loop は無限ループ(break で終了、戻り値を返せる)
    let mut count = 0;
    let result = loop {
        count += 1;
        if count == 5 {
            break count * 2; // break の後に値を置くと、それが loop の戻り値になる
        }
    };
    println!("loop の戻り値: {}", result);

    // while 条件ループ
    let mut n = 3;
    while n > 0 {
        println!("カウントダウン: {}", n);
        n -= 1;
    }

    // for in による反復(最も一般的)
    let items = ["apple", "banana", "cherry"];
    for (i, item) in items.iter().enumerate() {
        println!("{} 番目: {}", i + 1, item);
    }

    // for in レンジ(範囲)反復
    for num in 1..=3 { // 1..=3 は 1, 2, 3 を表す(両端を含む)
        println!("数: {}", num);
    }
}

関数

Rust の関数はfnキーワードで宣言します。引数と戻り値には型を明示的に指定する必要があります。最後の式の値が戻り値になります(return キーワードは不要)。

例

// 通常の関数:2つの i32 を受け取り、その和を返す
fn add(a: i32, b: i32) -> i32 {
    a + b  // 最後の式が自動的に戻り値になる(末尾にセミコロンがないことに注意)
}

// 複数の戻り値:タプルを使って複数の値を返す
fn divide(a: f64, b: f64) -> (f64, String) {
    if b == 0.0 {
        return (0.0, String::from("エラー:除数をゼロにできません"));
    }
    (a / b, String::from("OK")) // タプルを返す
}

// ジェネリック関数:trait bound で型パラメータの振る舞いを制約する
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

fn main() {
    // 通常の関数を呼び出す
    let sum = add(10, 20);
    println!("10 + 20 = {}", sum);

    // 複数の戻り値を持つ関数を呼び出す
    let (result, msg) = divide(10.0, 2.0);
    println!("10 / 2 = {} ({})", result, msg);

    // ゼロ除算の場合
    let (result, msg) = divide(10.0, 0.0);
    println!("10 / 0 = {} ({})", result, msg);

    // ジェネリック関数を呼び出す
    let nums = vec![3, 7, 2, 9, 5];
    println!("サンプル 最大値: {}", largest(&nums));
}

構造体と impl ブロック

Rust ではstructstruct を使用してデータ構造を定義し、implimpl ブロックで構造体にメソッドを実装します。これは Go のメソッド定義に似ていますが、言語の構成はよりコンパクトです。

例

// 構造体を定義(C の struct に似ているが、より高機能)
struct User {
    name: String,         // String 型。データの所有権を持つ
    email: String,
    active: bool,
    login_count: u64,     // u64 符号なし64ビット整数
}

// impl ブロックで User にメソッドを実装
impl User {
    // 関連関数(静的メソッドに類似):新しいインスタンスを作成
    fn new(name: String, email: String) -> User {
        User {
            name,
            email,
            active: true,     // デフォルト値
            login_count: 0,   // デフォルト値
        }
    }

    // メソッド:&self はインスタンスへの不変参照を表す
    fn summary(&self) -> String {
        format!("{} ({}) - ログイン回数: {}", self.name, self.email, self.login_count)
    }

    // メソッド:&mut self はインスタンスへの可変参照を表す
    fn login(&mut self) {
        self.login_count += 1;
    }
}

fn main() {
    // 関連関数を使ってインスタンスを作成
    let mut user = User::new(
        String::from("サンプル"),
        String::from("サンプル@example.com"),
    );

    println!("{}", user.summary());

    // ログインをシミュレート
    user.login();
    user.login();
    println!("ログイン {} 回", user.login_count);
}

よく使う例

以下では、実際のシナリオに近い2つの完全な例を通して、Rust の実開発における典型的な使い方を示します。

HTTP APIサービスの構築

Axum フレームワーク(Tokio 非同期ランタイムベース)を使用して、JSON レスポンスを返す HTTP API を構築します。

まず Cargo.toml に依存関係を追加します:

# Cargo.toml
[dependencies]
axum = "0.8"              # Web 框架
tokio = { version = "1", features = ["full"] }  # 异步运行时
serde = { version = "1", features = ["derive"] } # 序列化
serde_json = "1"           # JSON 支持

例

// ファイルパス:src/main.rs
use axum::{
    extract::Query,
    response::Json,
    routing::get,
    Router,
};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

// リクエストパラメータ構造体(デシリアライズ)
#[derive(Deserialize)]
struct HelloParams {
    name: Option<String>, // Option はオプションのパラメータを表す
}

// レスポンス構造体(シリアライズ)
#[derive(Serialize)]
struct ApiResponse {
    code: u16,
    message: String,
    data: Option<HashMap<String, String>>, // オプションのデータフィールド
}

// GET /hello リクエストを処理
// Query(HelloParams) が URL のクエリパラメータから name を自動的に抽出
async fn hello_handler(Query(params): Query<HelloParams>) -> Json<ApiResponse> {
    let name = params.name.unwrap_or_else(|| String::from("サンプル"));

    let mut data = HashMap::new();
    data.insert("name".to_string(), name.clone());

    Json(ApiResponse {
        code: 200,
        message: format!("こんにちは、{}!Rust HTTP サービスへようこそ", name),
        data: Some(data),
    })
}

// #[tokio::main] マクロは async fn main を Tokio ランタイムに変換する
#[tokio::main]
async fn main() {
    // ルーティングを構築
    let app = Router::new()
        .route("/hello", get(hello_handler));

    // アドレスにバインドしてサービスを起動
    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080")
        .await
        .unwrap();

    println!("サンプル サーバー起動、リスニングアドレス: http://localhost:8080");
    println!("アクセス例: http://localhost:8080/hello?name=Rust開発者");

    axum::serve(listener, app).await.unwrap();
}
$ cargo run
サンプル 服务器启动,监听地址: http://localhost:8080
访问示例: http://localhost:8080/hello?name=Rust开发者

# 使用 curl 测试
$ curl http://localhost:8080/hello?name=Rust开发者
{"code":200,"message":"你好,Rust开发者!欢迎访问 Rust HTTP 服务","data":{"name":"Rust开发者"}}

$ curl http://localhost:8080/hello
{"code":200,"message":"你好,サンプル!欢迎访问 Rust HTTP 服务","data":{"name":"サンプル"}}

Axum は Rust エコシステムで最も人気のある Web フレームワークの1つで、Tokio チームによってメンテナンスされています。Rust の型システムを最大限に活用し、ルートパラメータの抽出や状態の共有などの操作をコンパイル時にチェックすることで、実行時エラーを大幅に削減します。

ファイル一括処理ツール

これは実際のシナリオに近い CLI ツールです。ディレクトリを再帰的に走査し、すべてのファイルの行数とサイズを集計し、拡張子ごとに分類してまとめます。

Cargo.toml に依存関係を追加します:

# Cargo.toml
[dependencies]
walkdir = "2"  # 递归遍历目录

例

// ファイルパス:src/main.rs
use std::collections::HashMap;
use std::fs;
use walkdir::WalkDir; // ディレクトリを再帰的に走査するサードパーティライブラリ

fn main() {
    let path = "."; // 現在のディレクトリからスキャン開始

    // 統計情報:ファイル拡張子ごとにグループ化
    // HashMap<拡張子, (ファイル数, 総行数, 総バイトサイズ)>
    let mut stats: HashMap<String, (usize, usize, u64)> = HashMap::new();

    // WalkDir はディレクトリを再帰的に走査し、隠しファイルと .git ディレクトリを自動的にスキップ
    for entry in WalkDir::new(path)
        .into_iter()
        .filter_map(|e| e.ok()) // アクセスできないエントリをフィルタリング
        .filter(|e| e.file_type().is_file()) // ファイルのみ処理する
    {
        // ファイル拡張子を取得する
        let ext = entry
            .path()
            .extension()
            .and_then(|e| e.to_str())
            .unwrap_or("(拡張子なし)")
            .to_lowercase();

        // ファイルの内容を読み取る(テキストファイルのみ。バイナリファイルは文字化けする可能性があるが統計には影響しない)
        if let Ok(content) = fs::read_to_string(entry.path()) {
            let line_count = content.lines().count();
            let size = entry.metadata().map(|m| m.len()).unwrap_or(0);

            let (count, lines, total_size) = stats.entry(ext).or_insert((0, 0, 0));
            *count += 1;
            *lines += line_count;
            *total_size += size;
        }
    }

    // ファイル数で降順に並べて出力する
    let mut sorted: Vec<_> = stats.into_iter().collect();
    sorted.sort_by(|a, b| b.1 .0.cmp(&a.1 .0));

    println!("=== サンプル ディレクトリファイル統計 ===");
    println!("{:<15} {:>8} {:>10} {:>12}", "拡張子", "ファイル数", "総行数", "総サイズ(bytes)");
    println!("{}", "-".repeat(50));
    for (ext, (count, lines, size)) in &sorted {
        println!("{:<15} {:>8} {:>10} {:>12}", ext, count, lines, size);
    }
}
$ cargo run --release
=== サンプル 目录文件统计 ===
扩展名            文件数       总行数   总大小(bytes)
--------------------------------------------------
rs                  12        856        28432
toml                 3         45         1534
md                   2        120         3412
html                 1        510        14256
(无扩展名)            1          8          210

よく使うツールとコマンド早見表

Cargo の標準機能以外にも、Rust エコシステムは開発効率を高める一連のツールを提供しています:

コマンド機能説明
rustup updateRust ツールチェーンを更新するrustc、cargo などを最新の安定版にアップグレードする
rustup component add rustfmtコードフォーマッタツールをインストールする保存時にコードを自動フォーマットする
rustup component add clippyコード検査ツールをインストールする推奨されない書き方や潜在的なバグを発見する
rustup docローカルドキュメントを開く標準ライブラリと The Book をオフラインで参照する
cargo add <crate>依存関係を追加するCargo.toml を自動編集して最新バージョンを取得する
cargo update依存関係のバージョンを更新するCargo.toml のバージョン制約に基づいて Cargo.lock を更新する
cargo tree依存関係ツリーを表示するプロジェクトの完全な依存関係を視覚化する
cargo benchベンチマークテストを実行するコードのパフォーマンスを計測する
cargo install <tool>Rust で書かれた CLI ツールをインストールする例:cargo install ripgrep

注意事項とよくある質問

以下は、Rust 初心者が最も直面しやすい課題とベストプラクティスの提案です。

コンパイラと「戦う」のは普通

Rust の学習曲線は、最初は急で後半は緩やかであると広く認められています。所有権と借用チェックは初心者の頃の最大の障壁です。

書いたコードがコンパイラに何度も拒否されても、落ち込まないでください——それはまさにコンパイラが潜在的な実行時バグを防いでくれている証拠です。経験を積むにつれて、Rust の流儀で考えることに徐々に慣れ、コンパイラは敵ではなく最も頼りになるパートナーになるでしょう。

String と &str の違い

これは Rust 初心者が最も混同しやすい概念です。Stringは所有権を持つヒープ割り当て文字列(変更可能)です。&strは文字列データへの不変参照(借用したビュー)で、通常は &String から自動的にデリファレンスされます。

例

fn main() {
    // String: 所有権を持ち、変更可能で、ヒープ上にある
    let mut s = String::from("Hello");

    // &str: 参照であり、変更不可、通常は関数の引数として使われる
    let slice: &str = "サンプル"; // 文字列リテラル自体が &str である

    s.push_str(", world!"); // String は変更可能
    println!("{}", s);
    println!("{}", slice);

    // 関数の引数には String ではなく &str を選ぶ方が柔軟
    greet("サンプル");          // &str を直接渡せる
    greet(&s);                // &String から自動的に &str に変換して渡すこともできる
}

fn greet(name: &str) {
    println!("こんにちは、{}!", name);
}

エラー処理:panic! vs Result

Rust は区別します回復不能なエラー(使用するpanic!、プログラムは終了)と回復可能なエラー(使用するResult、呼び出し側が処理方法を決定する)。

ライブラリコードでは、panic! ではなく Result を返し、呼び出し側に選択権を与えるべきです。アプリケーションでは、状況に応じて判断できます。

unsafe:慎重に使うが、必要

Rust はunsafeunsafe キーワードを提供しており、裸のポインタ操作、外部関数呼び出し(FFI)などの低レベル操作を可能にします。

unsafe は「安全チェックの無効化」ではなく、コンパイラが自動的に保証できない部分の安全責任を開発者が負うことを意味します。ほとんどのアプリケーションコードでは unsafe を使う必要はありません——頻繁に使っていることに気づいたら、設計を見直す必要があるかもしれません。

コンパイル時間が長い

Rust はコンパイル時間が長いことで知られています。特に大規模プロジェクトでは顕著です。これは、コンパイラがコンパイル時に多くの検査(所有権分析、ライフタイム検証、trait 解決など)と最適化を行うためです。

軽減策:使用するcargo checkcargo build の代わりに日常開発を行う;大きな crate をサブ crate に分割してインクリメンタルコンパイルを活用する;使用するsccacheコンパイル結果をキャッシュする;ハードウェアをアップグレードする(特に SSD とより多くの CPU コア)。

学習パスの提案

Rust 初心者には、以下の学習順序をお勧めします:

  • 通読するThe Rust Programming Language(公式の書籍、無料)、所有権の章を重点的に理解する
  • Rust Playground(play.rust-lang.org)で読みながら書き、即座にコンパイラからのフィードバックを得る
  • を通じてRustlings小さな練習問題を解いて、構文を定着させる
  • 読むRust by Example、実例を通して学ぶ
  • 自分がよく知っている小さなプロジェクトを Rust で書き直してみて、実践を通して Rust の設計トレードオフを理解する

まとめ

Rust はメモリ安全性(GC なし)、ゼロコスト抽象と恐れることのない並行性(fearless concurrency)という 3 つの核となる強みにより、システムプログラミング、高性能サービス、WebAssembly、ブロックチェーンなどの分野で独自のエコシステム的位置を確立しています。

学習曲線は急ですが、コンパイラの厳格な検査は長期的なプロジェクトにおいて非常に高いコード品質と保守性をもたらします——これが、ますます多くの企業やオープンソースプロジェクトが Rust を選ぶ理由です。

Rust の強みと適用シーンは以下の通りです:

観点Rust の特徴
学習曲線比較的急(所有権システムの理解と適応が必要)だが、概念は安定しており、習得後は生涯にわたって役立つ
コンパイル速度比較的遅い(多くのコンパイル時チェックがある)が、cargo check とインクリメンタルコンパイルで軽減できる
実行時パフォーマンスC/C++ と同等で、GC を持つ言語をはるかに上回る
メモリ安全性コンパイル時に保証され、GC 不要、ヌルポインタ、ダングリングポインタ、バッファオーバーフローがない
並行性の安全性コンパイル時にデータ競合を排除し、並行性を恐れない
エコシステムの成熟度急速に成長しており、システムプログラミング、WebAssembly、ブロックチェーン分野ではすでに非常に成熟している
最も適しているシステムプログラミング、高性能バックエンド、WebAssembly、組み込み、ブロックチェーン、CLI ツール、データベース
あまり適していない高速プロトタイピング開発(コンパイル時間)、GUI デスクトップアプリ、ゲーム開発(成熟したエンジンとの比較)
その他の拡張