Rust チュートリアル完全ガイド｜初心者が最速で習得する方法

Rustとは？今チュートリアルを始めるべき理由

「新しいプログラミング言語を学びたいけど、Rustって難しそう…」と感じていませんか？確かにRustは学習曲線がやや急だと言われています。しかし、正しいチュートリアルの手順を踏めば、初心者でも着実にスキルを身につけられます。

この記事では、Rustの環境構築から基本文法、所有権の理解、そして実践的なプロジェクト作成まで、ステップバイステップで解説します。Rustチュートリアルの決定版として、あなたの学習を全力でサポートします。

Rustが世界中のエンジニアに選ばれる理由

Rustは、Mozillaが開発したシステムプログラミング言語です。2015年にバージョン1.0がリリースされて以来、急速に人気を拡大しています。Stack Overflowの開発者調査では、8年連続で「最も愛されているプログラミング言語」に選ばれました。

では、なぜこれほど多くのエンジニアがRustを支持するのでしょうか。その理由を具体的に見ていきましょう。

メモリ安全性をコンパイル時に保証

C言語やC++では、メモリの管理はプログラマーの責任です。バッファオーバーフローやダングリングポインタなどのバグが発生しやすく、セキュリティ上の脆弱性につながることもあります。

Rustでは、「所有権（Ownership）」という独自の仕組みにより、コンパイル時にメモリ安全性を保証します。ガベージコレクション（GC）を使わずにメモリ管理を行うため、実行時のパフォーマンスも犠牲になりません。

C/C++に匹敵するパフォーマンス

Rustはゼロコスト抽象化を採用しています。高レベルな書き方をしても、コンパイル後のコードは低レベル言語と同等の速度で動作します。WebサーバーやOS開発、ゲームエンジンなど、高速処理が求められる領域で特に力を発揮します。

モダンな開発体験

RustにはCargoという強力なパッケージマネージャーが標準搭載されています。依存関係の管理、ビルド、テスト、ドキュメント生成がすべてCargoひとつで完結します。JavaのMavenやNode.jsのnpmに相当するツールです。

採用企業の急増

Rustは大手テクノロジー企業でも急速に採用が進んでいます。

• Google：Android OSの一部をRustで書き換え
• Microsoft：Windowsカーネルの一部にRustを導入
• Amazon（AWS）：FirecrackerなどのインフラツールをRustで開発
• Meta（Facebook）：バックエンドサービスにRustを採用
• Cloudflare：エッジコンピューティング基盤にRustを活用

日本国内でも、大手自動車メーカーの組み込みシステムや金融機関のバックエンドシステムでRustの採用事例が増えています。株式会社アイティークロスでも、大手自動車メーカーや金融機関の案件でRust対応エンジニアの需要が高まっているのを実感しています。

Rust チュートリアル Step1：環境構築を完了させよう

Rustのチュートリアルを始めるには、まず開発環境を整える必要があります。ここでは、Windows・Mac・Linuxそれぞれの環境構築方法を解説します。

rustupのインストール

rustupは、Rustのバージョン管理ツールです。公式が推奨するインストール方法なので、まずはこちらをセットアップしましょう。

Mac/Linuxの場合：

ターミナルを開き、以下のコマンドを実行します。

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

インストールが完了したら、ターミナルを再起動して以下のコマンドでバージョンを確認してください。

rustc --version

「rustc 1.xx.x」のような表示が出れば、インストール成功です。

Windowsの場合：

Rust公式サイト（https://www.rust-lang.org/）から「rustup-init.exe」をダウンロードして実行します。事前にVisual Studio C++ Build Toolsのインストールが必要です。Microsoft公式サイトからダウンロードできます。

エディタの設定

Rustの開発にはVisual Studio Code（VS Code）が最もおすすめです。以下の拡張機能をインストールしましょう。

• rust-analyzer：コード補完、型推論の表示、エラー検出
• CodeLLDB：デバッグサポート
• Even Better TOML：Cargo.tomlの編集サポート

これらの拡張機能を入れることで、コーディング中にリアルタイムでエラーが表示され、学習効率が大幅に向上します。

最初のプロジェクトを作成

環境構築が完了したら、Cargoを使って最初のプロジェクトを作ってみましょう。

cargo new hello_rust
cd hello_rust
cargo run

ターミナルに「Hello, world!」と表示されれば成功です。おめでとうございます。これであなたのRustチュートリアルが本格的にスタートします。

プロジェクト構成を理解する

Cargoが生成したプロジェクトの構成を確認しましょう。

Cargo.tomlはNode.jsのpackage.jsonに相当するファイルです。プロジェクト名、バージョン、依存ライブラリ（クレートと呼びます）をここで管理します。

Rust チュートリアル Step2：基本文法をマスターしよう

環境構築が完了したら、Rustの基本文法を学んでいきましょう。他の言語経験がある方も、Rust特有の書き方があるので丁寧に確認してください。

変数と可変性

Rustでは、変数はデフォルトで不変（immutable）です。これは他の多くの言語と大きく異なる点です。

fn main() {
    let x = 5;       // 不変の変数
    // x = 10;        // コンパイルエラー！

let mut y = 5;    // 可変の変数（mutキーワード）
    y = 10;           // OK

println!("x = {}, y = {}", x, y);
}

不変がデフォルトである理由は、予期しない値の変更を防ぎ、バグを減らすためです。値を変更する必要がある場合のみ、mutキーワードを付けます。

データ型

Rustは静的型付け言語です。コンパイル時にすべての変数の型が決まっている必要があります。ただし、型推論が強力なので、多くの場合は明示的に型を書く必要はありません。

主要なデータ型を見てみましょう。

fn main() {
    let age: u32 = 28;
    let pi: f64 = 3.14159;
    let is_active: bool = true;
    let greeting: &str = "こんにちは";
    let name: String = String::from("Rust");

println!("{} {}歳 {} {} {}", greeting, age, pi, is_active, name);
}

関数の定義

Rustではfnキーワードで関数を定義します。引数と戻り値の型は必ず明示します。

fn add(a: i32, b: i32) -> i32 {
    a + b  // セミコロンなし = 戻り値（式として評価される）
}

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

fn main() {
    let result = add(3, 5);
    println!("3 + 5 = {}", result);
    greet("太郎");
}

注目すべきポイントは、最後の式にセミコロンを付けないと、それが戻り値になるという点です。returnキーワードも使えますが、Rustでは式ベースのスタイルが一般的です。

条件分岐とループ

Rustの条件分岐にはif式を使います。「式」なので、値を返すことができます。

fn main() {
    let score = 85;

// if式で値を返す
    let grade = if score >= 90 {
        "A"
    } else if score >= 80 {
        "B"
    } else {
        "C"
    };

println!("成績: {}", grade);  // 成績: B

// ループの種類
    // 1. loop（無限ループ）
    let mut count = 0;
    let result = loop {
        count += 1;
        if count == 10 {
            break count * 2;  // loopも値を返せる
        }
    };
    println!("result: {}", result);  // result: 20

// 2. while
    let mut n = 3;
    while n > 0 {
        println!("{}!", n);
        n -= 1;
    }

// 3. for（最もよく使う）
    for i in 0..5 {
        println!("i = {}", i);
    }
}

match式（パターンマッチング）

Rustのmatch式は、他言語のswitch文を大幅に強化したものです。すべてのパターンを網羅する必要があり、漏れがあるとコンパイルエラーになります。

fn describe_number(n: i32) -> &'static str {
    match n {
        1 => "一",
        2 => "二",
        3..=9 => "三から九のどれか",
        10 | 20 => "十か二十",
        _ => "その他",  // ワイルドカード（必須）
    }
}

fn main() {
    println!("{}", describe_number(5));   // 三から九のどれか
    println!("{}", describe_number(10));  // 十か二十
}

match式はRustプログラミングの核心的な機能です。このチュートリアルで基本を押さえておきましょう。

Rust チュートリアル Step3：所有権を理解しよう

ここからがRust学習の最大の山場です。所有権（Ownership）はRustを他の言語と決定的に区別する概念であり、多くの初学者がつまずくポイントです。しかし、一度理解すれば、Rustの強力さを実感できるはずです。

所有権の3つのルール

Rustの所有権は、以下の3つのルールに基づいています。

1. Rustの各値は「所有者」（owner）と呼ばれる変数を持つ
2. 一度に所有者になれるのは1つの変数だけ
3. 所有者がスコープを抜けると、値は自動的に破棄（drop）される

具体的なコードで見てみましょう。

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // 所有権がs1からs2に「移動（move）」

// println!("{}", s1);  // コンパイルエラー！s1はもう使えない
    println!("{}", s2);     // OK
}

Pythonではs2 = s1と書くと両方の変数が同じオブジェクトを参照しますが、Rustでは所有権が移動（ムーブ）します。これにより、二重解放やデータ競合といったメモリ関連のバグを防いでいます。

参照と借用

所有権を渡さずにデータを使いたい場合は、「参照（reference）」を使います。これを「借用（borrowing）」と呼びます。

fn calculate_length(s: &String) -> usize {
    s.len()
}  // sはここでスコープを抜けるが、所有権を持っていないのでdropされない

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1);  // 参照を渡す（借用）

println!("'{}'の長さは{}", s1, len);  // s1はまだ使える！
}

参照には2つの種類があります。

fn main() {
    let mut s = String::from("hello");

// 不変参照は複数OK
    let r1 = &s;
    let r2 = &s;
    println!("{} {}", r1, r2);

// 可変参照は同時に1つだけ
    let r3 = &mut s;
    r3.push_str(", world");
    println!("{}", r3);
}

このルールにより、データ競合がコンパイル時に検出されます。マルチスレッドプログラミングでも安全性が保証されるのが、Rustの最大の魅力です。

ライフタイム

ライフタイム（Lifetime）は、参照がどの期間有効であるかをコンパイラに伝える仕組みです。多くの場合、コンパイラが自動的に推論してくれます。

// ライフタイム注釈が必要な例
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

fn main() {
    let string1 = String::from("長い文字列");
    let result;
    {
        let string2 = String::from("短い");
        result = longest(string1.as_str(), string2.as_str());
        println!("より長いのは: {}", result);
    }
}

ライフタイムは最初のうちは理解しにくい概念ですが、コンパイラのエラーメッセージに従って修正していくうちに、自然と感覚がつかめてきます。

Rust チュートリアル Step4：構造体・列挙型・トレイト

基本文法と所有権を学んだら、次はRustのデータ構造について理解を深めましょう。

構造体（Struct）

構造体は、関連するデータをまとめるための型です。

#[derive(Debug)]
struct User {
    username: String,
    email: String,
    age: u32,
    active: bool,
}

impl User {
    // 関連関数（コンストラクタ的な役割）
    fn new(username: String, email: String, age: u32) -> User {
        User {
            username,
            email,
            age,
            active: true,
        }
    }

// メソッド（&selfを取る）
    fn introduction(&self) -> String {
        format!("{}（{}歳）- {}", self.username, self.age, self.email)
    }
}

fn main() {
    let user = User::new(
        String::from("tanaka"),
        String::from("tanaka@example.com"),
        28,
    );
    println!("{}", user.introduction());
    println!("{:?}", user);  // Debugトレイトによる表示
}

列挙型（Enum）

Rustの列挙型は非常に強力です。各バリアントがデータを持つことができます。

enum WebEvent {
    PageLoad,
    Click { x: i64, y: i64 },
    KeyPress(char),
    Paste(String),
}

fn handle_event(event: WebEvent) {
    match event {
        WebEvent::PageLoad => println!("ページが読み込まれました"),
        WebEvent::Click { x, y } => println!("クリック位置: ({}, {})", x, y),
        WebEvent::KeyPress(c) => println!("キー入力: {}", c),
        WebEvent::Paste(text) => println!("ペースト: {}", text),
    }
}

fn main() {
    handle_event(WebEvent::Click { x: 100, y: 200 });
    handle_event(WebEvent::KeyPress('a'));
}

Option型とResult型

Rustにはnull（None）がありません。代わりにOption<T>型を使います。

fn find_user(id: u32) -> Option<String> {
    match id {
        1 => Some(String::from("tanaka")),
        2 => Some(String::from("suzuki")),
        _ => None,
    }
}

fn main() {
    match find_user(1) {
        Some(name) => println!("ユーザー: {}", name),
        None => println!("ユーザーが見つかりません"),
    }

// if letによる簡潔な書き方
    if let Some(name) = find_user(3) {
        println!("ユーザー: {}", name);
    } else {
        println!("ユーザーが見つかりません");
    }
}

エラー処理にはResult<T, E>型を使います。

use std::fs;

fn read_config() -> Result<String, std::io::Error> {
    fs::read_to_string("config.toml")
}

fn main() {
    match read_config() {
        Ok(content) => println!("設定内容: {}", content),
        Err(e) => println!("エラー: {}", e),
    }
}

?演算子を使うと、エラー処理をさらに簡潔に書けます。これはRust初心者のチュートリアルで必ず押さえておくべきポイントです。

トレイト（Trait）

トレイトは、他言語でいうインターフェースに相当する概念です。型が持つべき振る舞いを定義します。

trait Summary {
    fn summarize(&self) -> String;

// デフォルト実装も可能
    fn preview(&self) -> String {
        format!("{}...", &self.summarize()[..20])
    }
}

struct Article {
    title: String,
    content: String,
}

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{}: {}", self.title, self.content)
    }
}

fn main() {
    let article = Article {
        title: String::from("Rustチュートリアル"),
        content: String::from("Rustは安全で高速なプログラミング言語です"),
    };
    println!("{}", article.summarize());
}

Rust チュートリアル Step5：実践プロジェクトに挑戦

ここまでの知識を活かして、実際にプロジェクトを作ってみましょう。このRustチュートリアルでは、3つの段階的なプロジェクトを紹介します。

プロジェクト1：TODOリストCLIアプリ

まずは、コマンドラインで動作するシンプルなTODOリストを作りましょう。

use std::io;

struct Todo {
    id: u32,
    title: String,
    completed: bool,
}

impl Todo {
    fn new(id: u32, title: String) -> Todo {
        Todo {
            id,
            title,
            completed: false,
        }
    }
}

fn main() {
    let mut todos: Vec<Todo> = Vec::new();
    let mut next_id: u32 = 1;

loop {
        println!("n--- TODOリスト ---");
        println!("1. 追加  2. 一覧  3. 完了  4. 終了");

let mut input = String::new();
        io::stdin().read_line(&mut input).unwrap();

match input.trim() {
            "1" => {
                println!("タスク名を入力:");
                let mut title = String::new();
                io::stdin().read_line(&mut title).unwrap();
                todos.push(Todo::new(next_id, title.trim().to_string()));
                next_id += 1;
                println!("追加しました！");
            }
            "2" => {
                for todo in &todos {
                    let status = if todo.completed { "✓" } else { " " };
                    println!("[{}] {}: {}", status, todo.id, todo.title);
                }
            }
            "3" => {
                println!("完了するタスクのIDを入力:");
                let mut id_input = String::new();
                io::stdin().read_line(&mut id_input).unwrap();
                if let Ok(id) = id_input.trim().parse::<u32>() {
                    if let Some(todo) = todos.iter_mut().find(|t| t.id == id) {
                        todo.completed = true;
                        println!("完了にしました！");
                    }
                }
            }
            "4" => break,
            _ => println!("無効な入力です"),
        }
    }
}

このプロジェクトでは、構造体、Vec（ベクタ）、ループ、match式、所有権、参照といった基本要素を実践的に使っています。

プロジェクト2：Web APIクライアント

外部のREST APIからデータを取得するクライアントを作ります。reqwestとserdeクレートを使用します。

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

[dependencies]
reqwest = { version = "0.11", features = ["json", "blocking"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

use serde::Deserialize;

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

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://jsonplaceholder.typicode.com/posts?_limit=5";
    let posts: Vec<Post> = reqwest::blocking::get(url)?.json()?;

for post in posts {
        println!("[{}] {}", post.id, post.title);
        println!("  {}", &post.body[..50.min(post.body.len())]);
        println!();
    }

Ok(())
}

このプロジェクトでは、外部クレートの利用、JSONのデシリアライズ、Result型によるエラーハンドリングを学べます。

プロジェクト3：Webサーバー（Actix Web）

RustでWebサーバーを構築するなら、Actix Webが人気のフレームワークです。簡単なREST APIを作ってみましょう。

use actix_web::{web, App, HttpServer, HttpResponse, Responder};
use serde::{Deserialize, Serialize};

#[derive(Serialize)]
struct Message {
    status: String,
    message: String,
}

async fn health_check() -> impl Responder {
    HttpResponse::Ok().json(Message {
        status: "ok".to_string(),
        message: "サーバーは正常に動作しています".to_string(),
    })
}

#[derive(Deserialize)]
struct UserQuery {
    name: Option<String>,
}

async fn greet(query: web::Query<UserQuery>) -> impl Responder {
    let name = query.name.as_deref().unwrap_or("ゲスト");
    HttpResponse::Ok().json(Message {
        status: "ok".to_string(),
        message: format!("こんにちは、{}さん！", name),
    })
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/health", web::get().to(health_check))
            .route("/greet", web::get().to(greet))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Actix Webは非同期処理（async/await）を活用しており、非常に高いパフォーマンスを発揮します。TechEmpower Frameworksベンチマークでは、常にトップクラスの性能を記録しています。

Rust学習を加速させるおすすめリソース

このチュートリアルで基礎を学んだ後、さらにRustスキルを伸ばすためのリソースを紹介します。

公式ドキュメント

• The Rust Programming Language（通称：The Book）：Rust公式の教科書。無料で読めます
• Rust by Example：サンプルコードで学ぶ公式チュートリアル
• Rustlings：小さな練習問題を解きながら学ぶインタラクティブな教材

書籍

• 「プログラミングRust 第2版」（オライリー）：体系的に学びたい人に最適
• 「実践Rustプログラミング入門」：日本語で書かれた実践向け入門書
• 「Rustハンズオン」：手を動かしながら学べる構成

オンライン学習プラットフォーム

• Exercism（Rustトラック）：メンター付きのコーディング演習
• LeetCode / AtCoder：Rustでアルゴリズム問題を解く
• Udemy：日本語のRust講座も増加中

コミュニティ

• Rust日本語コミュニティ（Zulip）：日本語で質問できる
• r/rust（Reddit）：英語の情報が豊富
• Rust Users Forum：公式フォーラム

Rustの学習には3〜6ヶ月程度の継続的な取り組みが必要です。焦らず、毎日少しずつコードを書く習慣をつけましょう。

Rustエンジニアのキャリアと市場価値

Rustスキルを身につけると、エンジニアとしての市場価値は大きく向上します。

Rustエンジニアの年収相場

2024年時点のRustエンジニアの年収相場は以下の通りです。

Rustエンジニアの需要は年々増加しており、特にインフラ系、ブロックチェーン、組み込みシステム分野での求人が目立ちます。

Rustが活かせる業界・案件

• 自動車業界：自動運転や車載システムの組み込み開発
• 金融業界：高頻度取引システム、ブロックチェーン
• クラウドインフラ：AWS、Azure向けのシステムツール開発
• ゲーム開発：ゲームエンジンの最適化
• WebAssembly：ブラウザ上で動作する高速アプリ

名古屋エリアでは、特に大手自動車メーカーの車載ソフトウェア開発でRustの需要が高まっています。株式会社アイティークロスでは、こうした最先端技術を使ったプロジェクトへの参画機会を積極的に提供しています。

Java、PHP、Python、JavaScriptといった既存のスキルにRustを加えることで、キャリアの幅が大きく広がります。アイティークロスでは充実した研修制度を用意しており、異業種からの転職者も5割以上在籍しています。新しい言語へのチャレンジをサポートする環境が整っています。

また、個人の希望を100%ヒアリングした上でプロジェクトをマッチングするため、「Rustを使った案件に携わりたい」という要望にも柔軟に対応可能です。年間休日125日、残業月平均12.3時間という働きやすい環境で、スキルアップに集中できるのも大きな魅力です。

まとめ：Rustチュートリアルの学習ロードマップ

この記事で解説したRustチュートリアルの内容を、学習ロードマップとして整理します。

1. 環境構築（1日目）：rustupのインストール、VS Codeの設定、Hello Worldの実行
2. 基本文法（1〜2週目）：変数、データ型、関数、条件分岐、ループ、match式
3. 所有権の理解（2〜3週目）：所有権、借用、参照、ライフタイムの基本
4. データ構造（3〜4週目）：構造体、列挙型、トレイト、Option/Result型
5. 実践プロジェクト（5〜8週目）：CLIアプリ、APIクライアント、Webサーバーの構築
6. 応用学習（2ヶ月目以降）：非同期処理、マクロ、unsafe Rust、クレートの公開

Rustは確かに学習難易度が高い言語ですが、その分、習得後の見返りは非常に大きいです。メモリ安全性、高パフォーマンス、モダンな開発体験を兼ね備えたRustは、これからのソフトウェア開発を支える重要な言語となるでしょう。

このチュートリアルを参考に、ぜひRustの世界に飛び込んでみてください。コンパイラとの格闘は大変ですが、それを乗り越えた先には、より安全で効率的なプログラミング体験が待っています。