Rust開発環境のセットアップと基本文法ガイド【2024年版】

Contents

1 開発環境のセットアップ
- 1.1 Rust のインストールとバージョン確認（安全に行う方法）
- 1.2 VSCode と Rust Analyzer の設定
  - 1.2.1 補足：Qiita 記事のリンク切れについて
2 Rust 基本文法と所有権入門
- 2.1 変数・データ型・制御フロー・関数定義
- 2.2 所有権・借用・ライフタイム
3 エラーハンドリングと標準ライブラリ活用
- 3.1 Result と Option の基本形
- 3.2 標準入力から文字列を受け取り加工する例
4 Cargo でプロジェクト管理と依存クレート
- 4.1 プロジェクトの作成・ビルド・テスト
- 4.2 代表的クレート serde と clap
  - 4.2.1 CLI 引数のパース（clap）
  - 4.2.2 JSON 設定ファイルの読み込み（serde）
5 実践ミニプロジェクトとテスト
- 5.1 ステップバイステップで作る「文字列大文字化」CLI ツール
- 5.2 ユニットテストの書き方と cargo test の活用
6 参考リンク・補足情報

スポンサードリンク

開発環境のセットアップ

Rust のインストールとバージョン確認（安全に行う方法）

結論
公式ツール rustup を利用すれば、Rust 本体 (rustc) とパッケージマネージャ (cargo) が同時に導入 できます。インストール後は以下のコマンドで 最新の安定版（執筆時点：2024‑04‑15）を確認できます。

rustc --version   # → rustc 1.78.0 (xxxxxx) ← 例示
cargo --version   # → cargo 1.78.0 (xxxxxx)

rustc --version # → rustc 1.78.0 (xxxxxx) ← 例示

cargo --version # → cargo 1.78.0 (xxxxxx)

1️⃣ `curl … | sh` のみを実行しない理由

curl https://sh.rustup.rs -sSf | sh は手軽ですが、スクリプトの改ざんリスク が完全に排除できません。安全性を高めるために次の手順を推奨します。

手順	コマンド例	説明
(a) インストーラ本体とハッシュ値を取得	`curl -sSfO https://static.rust-lang.org/rustup/dist/x86_64-unknown-linux-gnu/rustup-init` `curl -sSfO https://static.rust-lang.org/rustup/rustup-init.sha256`	公式サーバーから直接ダウンロード
(b) ハッシュを検証	`sha256sum -c rustup-init.sha256`	ダウンロードしたファイルの SHA‑256 が公式と一致するか確認
(c) GPG 署名が提供されている場合は検証（2024‑04‑15 時点では未提供）	—	将来的に提供されたら `gpg --verify` を実行
(d) 実行権限を付与しインストール	`chmod +x rustup-init && ./rustup-init -y`	`-y` で対話なしインストール（必要なら `--no-modify-path`）

ポイント
Linux・macOS のみならず、Windows でも公式サイトの MSI パッケージや winget install Rustlang.rustup が利用できます。パッケージマネージャ経由の場合は OS が提供する署名チェックが自動で走ります。

2️⃣ インストール後の環境変数設定

# Bash / Zsh の場合
source &quot;$HOME/.cargo/env&quot;

# Bash / Zsh の場合

source "$HOME/.cargo/env"

rustup は $HOME/.cargo/bin をパスに追加します。シェル起動時に自動で読み込むよう、.profile や .zshrc に上記行を追記しておくと便利です。

3️⃣ バージョン確認

rustup show        # インストールされたツールチェーン一覧
rustc --version    # 現在使用中のコンパイラバージョン
cargo --version

rustup show # インストールされたツールチェーン一覧

rustc --version # 現在使用中のコンパイラバージョン

cargo --version

VSCode と Rust Analyzer の設定

結論
VSCode に公式拡張機能 Rust Analyzer を導入すれば、コード補完・リアルタイムエラー表示・リファクタリング支援が即座に利用できます。

手順	操作
1️⃣ VSCode 起動 → 拡張機能パネル（左サイドバーの四角いアイコン）
2️⃣ 「Rust Analyzer」で検索し、`rust-analyzer` をインストール
3️⃣ 設定 (`Ctrl+,`) で `rust-analyzer.cargo-watch.enable = true` にチェック	保存時に自動ビルドが走ります
4️⃣ （任意）`settings.json` に以下を追記して快適化	`json<br>{<br> "rust-analyzer.checkOnSave.command": "clippy",<br> "editor.formatOnSave": true<br>}<br>`

補足：Qiita 記事のリンク切れについて

元記事で参照されていた 「超超初心者向けRustチュートリアル #Linux」（Qiita, automation2025）は 2023 年に削除された可能性があります。代替として、公式の Rust 入門書「The Rust Programming Language」（通称 The Book）の日本語版が最も信頼できる情報源です。

📖 日本語版 The Book: https://doc.rust-jp.rs/book/
📚 Rust By Example（実例中心）: https://doc.rust-jp.rs/rust-by-example/

Rust 基本文法と所有権入門

変数・データ型・制御フロー・関数定義

fn main() {
    // ── 変数宣言 ───────────────────────
    let immutable: i32 = 10;          // デフォルトはイミュータブル
    let mut mutable: i32 = 20;        // `mut` が必要

    // ── 条件分岐 ───────────────────────
    if immutable &lt; mutable {
        println!(&quot;immutable は mutable より小さい&quot;);
    } else {
        println!(&quot;immutable は mutable 以上&quot;);
    }

    // ── 繰り返し (for) ─────────────────
    for i in 0..3 {
        println!(&quot;i = {}&quot;, i);
    }

    // ── 関数呼び出し ───────────────────
    let sum = add(immutable, mutable);
    println!(&quot;sum = {}&quot;, sum);
}

// 戻り値は式の最後の評価結果になる
fn add(a: i32, b: i32) -&gt; i32 {
    a + b
}

fn main() {

// ── 変数宣言 ───────────────────────

let immutable: i32 = 10; // デフォルトはイミュータブル

let mut mutable: i32 = 20; // `mut` が必要

// ── 条件分岐 ───────────────────────

if immutable < mutable {

println!("immutable は mutable より小さい");

} else {

println!("immutable は mutable 以上");

}

// ── 繰り返し (for) ─────────────────

for i in 0..3 {

println!("i = {}", i);

}

// ── 関数呼び出し ───────────────────

let sum = add(immutable, mutable);

println!("sum = {}", sum);

}

// 戻り値は式の最後の評価結果になる

fn add(a: i32, b: i32) -> i32 {

a + b

}

キーワード	用途
`let`	変数宣言（デフォルトでイミュータブル）
`mut`	可変性を付与
`if / else`	条件分岐
`match`	パターンマッチング
`for`, `while`, `loop`	ループ構文

ポイント
Rust の式は最後の行が暗黙的に return になるので、return キーワードは省略可能です（早期リターンが必要なときだけ明示します）。

所有権・借用・ライフタイム

fn main() {
    // 1&#xfe0f;&#x20e3; 所有権の生成
    let s = String::from(&quot;hello&quot;);   // `s` がヒープ上の文字列を所有

    // 2&#xfe0f;&#x20e3; ムーブ（所有権移動）
    let t = s;                       // `s` は無効化、以後使用不可
    // println!(&quot;{}&quot;, s);           // ← コンパイルエラー

    // 3&#xfe0f;&#x20e3; 不変参照（borrow）
    let len = calc_len(&amp;t);
    println!(&quot;len = {}&quot;, len);

    // 4&#xfe0f;&#x20e3; 可変参照（mutable borrow）
    let mut u = String::from(&quot;rust&quot;);
    make_uppercase(&amp;mut u);
    println!(&quot;{}&quot;, u);               // &quot;RUST&quot;
}

// 不変借用だけなので所有権は移動しない
fn calc_len(s: &amp;String) -&gt; usize {
    s.len()
}

// 可変参照を受け取り、内容を書き換える例
fn make_uppercase(s: &amp;mut String) {
    *s = s.to_uppercase();
}

fn main() {

// 1️⃣ 所有権の生成

let s = String::from("hello"); // `s` がヒープ上の文字列を所有

// 2️⃣ ムーブ（所有権移動）

let t = s; // `s` は無効化、以後使用不可

// println!("{}", s); // ← コンパイルエラー

// 3️⃣ 不変参照（borrow）

let len = calc_len(&t);

println!("len = {}", len);

// 4️⃣ 可変参照（mutable borrow）

let mut u = String::from("rust");

make_uppercase(&mut u);

println!("{}", u); // "RUST"

}

// 不変借用だけなので所有権は移動しない

fn calc_len(s: &String) -> usize {

s.len()

}

// 可変参照を受け取り、内容を書き換える例

fn make_uppercase(s: &mut String) {

*s = s.to_uppercase();

}

用語	説明
所有権 (owner)	値がどこに属しているかを管理。スコープ抜けで自動的に `drop` される
ムーブ (move)	所有権の転送。元の変数は以後使用不可
借用 (borrow)	`&T`（不変）または `&mut T`（可変）で所有権を保持したまま参照だけ取得
ライフタイム	参照が有効な範囲。コンパイラが自動推論するが、必要に応じて `'a` のように明示

注意
同時に複数の可変参照は許されません（データ競合防止）。不変参照と可変参照も混在できない点に留意してください。

エラーハンドリングと標準ライブラリ活用

`Result` と `Option` の基本形

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

fn read_file(path: &amp;str) -&gt; Result&lt;String, io::Error&gt; {
    let mut f = File::open(path)?;          // エラーは呼び出し元へ伝搬
    let mut buf = String::new();
    f.read_to_string(&amp;mut buf)?;
    Ok(buf)
}

fn parse_number(s: &amp;str) -&gt; Option&lt;i32&gt; {
    s.trim().parse::&lt;i32&gt;().ok()           // Err のとき None を返す
}

use std::fs::File;

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

fn read_file(path: &str) -> Result<String, io::Error> {

let mut f = File::open(path)?; // エラーは呼び出し元へ伝搬

let mut buf = String::new();

f.read_to_string(&mut buf)?;

Ok(buf)

}

fn parse_number(s: &str) -> Option<i32> {

s.trim().parse::<i32>().ok() // Err のとき None を返す

}

Result<T, E> は「成功 (Ok)」か「失敗 (Err)」の二択。
Option<T> は「値がある (Some)」か「無い (None)」の二択。
? 演算子は Result / Option のエラープロパゲーションを簡潔に記述でき、早期リターンを自動化します。

標準入力から文字列を受け取り加工する例

use std::io::{self, Write};

fn main() -&gt; Result&lt;(), io::Error&gt; {
    // プロンプト表示 → バッファフラッシュで即座に出力
    print!(&quot;入力文字列: &quot;);
    io::stdout().flush()?;   // flush が失敗したら ? で伝搬

    let mut input = String::new();
    io::stdin().read_line(&amp;mut input)?;   // EOF や I/O エラーは自動的に `Err` に

    // トリム + 大文字化（所有権を移さず &amp;str を借用）
    let processed = input.trim().to_uppercase();

    println!(&quot;加工結果: {}&quot;, processed);
    Ok(())
}

use std::io::{self, Write};

fn main() -> Result<(), io::Error> {

// プロンプト表示 → バッファフラッシュで即座に出力

print!("入力文字列: ");

io::stdout().flush()?; // flush が失敗したら ? で伝搬

let mut input = String::new();

io::stdin().read_line(&mut input)?; // EOF や I/O エラーは自動的に `Err` に

// トリム + 大文字化（所有権を移さず &str を借用）

let processed = input.trim().to_uppercase();

println!("加工結果: {}", processed);

Ok(())

}

read_line は改行コードも含むため、trim() で除去しています。
to_uppercase() は新しい String を生成し、所有権が戻ります。

Cargo でプロジェクト管理と依存クレート

プロジェクトの作成・ビルド・テスト

# 1&#xfe0f;&#x20e3; 新規バイナリプロジェクト作成
cargo new hello_cli --bin
cd hello_cli

# 2&#xfe0f;&#x20e3; ビルド &amp; 実行
cargo build          # デバッグビルド（target/debug/ に生成）
cargo run            # コンパイル＋実行

# 3&#xfe0f;&#x20e3; テストの追加と実行
# src/main.rs の下にテストコードを書いたら
cargo test           # ユニットテストが自動走査・実行される

# 1️⃣ 新規バイナリプロジェクト作成

cargo new hello_cli --bin

cd hello_cli

# 2️⃣ ビルド & 実行

cargo build # デバッグビルド（target/debug/ に生成）

cargo run # コンパイル＋実行

# 3️⃣ テストの追加と実行

# src/main.rs の下にテストコードを書いたら

cargo test # ユニットテストが自動走査・実行される

Cargo.toml の [dependencies] にクレート名とバージョンを書くだけで、cargo build 時に自動取得します。
プロファイル ([profile.release]) を調整すればリリースビルドの最適化も簡単です。

代表的クレート `serde` と `clap`

# Cargo.toml の抜粋
[dependencies]
clap   = { version = &quot;4.5&quot;, features = [&quot;derive&quot;] }
serde  = { version = &quot;1.0&quot;, features = [&quot;derive&quot;] }
serde_json = &quot;1.0&quot;

# Cargo.toml の抜粋

[dependencies]

clap = { version = "4.5", features = ["derive"] }

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

serde_json = "1.0"

CLI 引数のパース（`clap`）

use clap::Parser;

#[derive(Parser, Debug)]
#[command(name = &quot;greeter&quot;)]
struct Args {
    /// 挨拶対象の名前
    #[arg(short, long, default_value = &quot;World&quot;)]
    name: String,
}

fn main() {
    let args = Args::parse();
    println!(&quot;Hello, {}!&quot;, args.name);
}

use clap::Parser;

#[derive(Parser, Debug)]

#[command(name = "greeter")]

struct Args {

/// 挨拶対象の名前

#[arg(short, long, default_value = "World")]

name: String,

}

fn main() {

let args = Args::parse();

println!("Hello, {}!", args.name);

}

JSON 設定ファイルの読み込み（`serde`）

use serde::Deserialize;
use std::{fs, io};

#[derive(Deserialize, Debug)]
struct Config {
    greeting: String,
    repeat:   u32,
}

fn load_config(path: &amp;str) -&gt; Result&lt;Config, io::Error&gt; {
    let data = fs::read_to_string(path)?;
    // serde_json のエラーは `io::Error` にラップ
    let cfg: Config = serde_json::from_str(&amp;data)
        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
    Ok(cfg)
}

use serde::Deserialize;

use std::{fs, io};

#[derive(Deserialize, Debug)]

struct Config {

greeting: String,

repeat: u32,

}

fn load_config(path: &str) -> Result<Config, io::Error> {

let data = fs::read_to_string(path)?;

// serde_json のエラーは `io::Error` にラップ

let cfg: Config = serde_json::from_str(&data)

.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;

Ok(cfg)

}

実務的な組み合わせ例
clap で取得したコマンドラインオプションと、serde が読んだ設定ファイルをマージすれば、柔軟かつ型安全な CLI アプリが完成します。

実践ミニプロジェクトとテスト

ステップバイステップで作る「文字列大文字化」CLI ツール

プロジェクト作成
bash cargo new text_upcase --bin cd text_upcase
依存クレート追加（任意）
clap を利用すれば引数オプションが簡単に実装できます。
main.rs 実装

use clap::Parser;
use std::io::{self, Write};

/// コマンドライン引数を定義
#[derive(Parser, Debug)]
#[command(name = &quot;text_upcase&quot;)]
struct Args {
    /// 直接文字列を渡す（省略時は標準入力）
    #[arg(short, long)]
    text: Option&lt;String&gt;,
}

/// 入力文字列 → トリム + 大文字化
fn process(input: &amp;str) -&gt; String {
    input.trim().to_uppercase()
}

fn main() -&gt; Result&lt;(), io::Error&gt; {
    let args = Args::parse();

    // ① 引数があればそれを使用、なければ stdin から取得
    let raw = if let Some(t) = args.text {
        t
    } else {
        print!(&quot;文字列を入力してください: &quot;);
        io::stdout().flush()?;               // バッファを書き出す
        let mut buf = String::new();
        io::stdin().read_line(&amp;mut buf)?;
        buf
    };

    // ② 加工 &amp; 出力
    println!(&quot;{}&quot;, process(&amp;raw));
    Ok(())
}

use clap::Parser;

use std::io::{self, Write};

/// コマンドライン引数を定義

#[derive(Parser, Debug)]

#[command(name = "text_upcase")]

struct Args {

/// 直接文字列を渡す（省略時は標準入力）

#[arg(short, long)]

text: Option<String>,

}

/// 入力文字列 → トリム + 大文字化

fn process(input: &str) -> String {

input.trim().to_uppercase()

}

fn main() -> Result<(), io::Error> {

let args = Args::parse();

// ① 引数があればそれを使用、なければ stdin から取得

let raw = if let Some(t) = args.text {

} else {

print!("文字列を入力してください: ");

io::stdout().flush()?; // バッファを書き出す

let mut buf = String::new();

io::stdin().read_line(&mut buf)?;

buf

};

// ② 加工 & 出力

println!("{}", process(&raw));

Ok(())

}

ビルド・実行例

cargo run -- --text &quot; hello rust &quot;
# =&gt; HELLO RUST

# 標準入力で利用する場合
echo &quot;  foo bar &quot; | cargo run --
# =&gt; FOOBAR

cargo run -- --text " hello rust "

# => HELLO RUST

# 標準入力で利用する場合

echo " foo bar " | cargo run --

# => FOOBAR

ユニットテストの書き方と `cargo test` の活用

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn basic() {
        assert_eq!(process(&quot; rust &quot;), &quot;RUST&quot;);
    }

    #[test]
    fn empty_input() {
        assert_eq!(process(&quot;\n\t  &quot;), &quot;&quot;);
    }
}

#[cfg(test)]

mod tests {

use super::*;

#[test]

fn basic() {

assert_eq!(process(" rust "), "RUST");

}

#[test]

fn empty_input() {

assert_eq!(process("\n\t "), "");

}

コマンド

cargo test

1 2	cargo test

出力例（省略可能なテストは #[ignore] でスキップできます）。

参考リンク・補足情報

内容	URL
Rust 公式入門書 The Book（日本語版）	https://doc.rust-jp.rs/book/
Rust By Example（実例中心）	https://doc.rust-jp.rs/rust-by-example/
`rustup` の公式インストール手順とチェックサム情報	https://rust-lang.org/ja/tools/install
VSCode 用 Rust Analyzer 拡張ページ	https://marketplace.visualstudio.com/items?itemName=matklad.rust-analyzer
Cargo の公式リファレンス	https://doc.rust-lang.org/cargo/
`clap` ドキュメント（v4）	https://docs.rs/clap/latest/clap/
`serde` と `serde_json` のクイックスタート	https://serde.rs/

更新情報：本稿は 2024‑04‑15 に執筆されました。Rust の最新安定版は執筆時点で 1.78 系ですが、以降のリリースがあった場合は rustup update で自動的に取得できます。

まとめ

安全なインストール：ハッシュ検証や GPG 署名（将来的に提供されたら）を行い、rustup による最新安定版導入を推奨。
IDE 環境：VSCode + Rust Analyzer が最も手軽かつフル機能。
言語基礎：所有権・借用・ライフタイムはコンパイル時安全性の根幹。例示コードで感覚を掴んでください。
エラーハンドリング：Result / Option + ? が標準的かつ推奨される書き方です。
プロジェクト管理：Cargo と代表クレート（serde, clap）を組み合わせれば、実務レベルの CLI が数十行で完成します。
テスト：#[cfg(test)] にユニットテストを書くだけで回帰防止が容易に。

この流れを踏めば、Rust 初学者でも「安全・高速」なプログラムを書きつつ、実務で通用する開発スキルを身につけられます。

スポンサードリンク

Rust開発環境のセットアップと基本文法ガイド【2024年版】

開発環境のセットアップ

Rust のインストールとバージョン確認（安全に行う方法）

1️⃣ curl … | sh のみを実行しない理由

2️⃣ インストール後の環境変数設定

3️⃣ バージョン確認

VSCode と Rust Analyzer の設定

補足：Qiita 記事のリンク切れについて

Rust 基本文法と所有権入門

変数・データ型・制御フロー・関数定義

所有権・借用・ライフタイム

エラーハンドリングと標準ライブラリ活用

Result と Option の基本形

標準入力から文字列を受け取り加工する例

Cargo でプロジェクト管理と依存クレート

プロジェクトの作成・ビルド・テスト

代表的クレート serde と clap

CLI 引数のパース（clap）

JSON 設定ファイルの読み込み（serde）

実践ミニプロジェクトとテスト

ステップバイステップで作る「文字列大文字化」CLI ツール

ユニットテストの書き方と cargo test の活用

参考リンク・補足情報

1️⃣ `curl … | sh` のみを実行しない理由

`Result` と `Option` の基本形

代表的クレート `serde` と `clap`

CLI 引数のパース（`clap`）

JSON 設定ファイルの読み込み（`serde`）

ユニットテストの書き方と `cargo test` の活用