Rustコマンド一覧【初心者向け完全ガイド】

By /

はい、承知いたしました。Rustのコマンド一覧について、初心者向けの完全ガイドとして約5000語の詳細な記事を作成します。

Rustコマンド一覧【初心者向け完全ガイド】

Rust言語での開発を始めるにあたって、コマンドラインツールの習得は避けて通れない道です。特に初心者の方は、「どのコマンドをいつ、どのように使えば良いのか？」と戸惑うことが多いでしょう。しかし、安心してください。Rustの開発で主に使うコマンドは限られており、その役割と基本的な使い方を理解すれば、スムーズに開発を進めることができます。

この記事では、Rust開発の最初のステップからプロジェクトの管理、ビルド、テスト、コード品質の向上まで、初心者が必要とする主要なコマンドを網羅し、それぞれの使い方を具体的な例を交えながら詳細に解説します。約5000語にわたるこのガイドを通して、Rustコマンドラインツールへの理解を深め、自信を持ってRust開発に取り組めるようになることを目指します。

1. はじめに：なぜコマンドが重要なのか？

Rustは、パフォーマンス、メモリ安全性、並行性を重視したシステムプログラミング言語です。その開発エコシステムは、強力なコマンドラインツールによって支えられています。これらのツールは、単にコードをコンパイルするだけでなく、依存関係の管理、プロジェクトの作成、テストの実行、コードフォーマット、ドキュメント生成など、開発ワークフローのあらゆる側面を効率化します。

特に初心者にとって、IDE（統合開発環境）を使う場合でも、背後ではこれらのコマンドが実行されています。コマンドの使い方を理解することで、IDEが何をしているのかを把握でき、トラブルシューティングやより高度な設定にも対応できるようになります。また、コマンドラインに慣れることは、Rustだけでなく、他の多くのプログラミング言語や開発環境でも役立つ普遍的なスキルです。

この記事では、Rust開発に不可欠な以下の主要コマンド群に焦点を当てます。

  • rustup: Rustツールチェイン（コンパイラや標準ライブラリなど）のインストールと管理
  • cargo: Rustプロジェクトのビルドシステムとパッケージマネージャー（依存関係管理、ビルド、実行、テストなど）
  • rustc: Rustコンパイラ（cargoが内部的に利用）

それでは、まずはRustの開発環境を整えるためのコマンドから見ていきましょう。

2. Rust開発環境のセットアップ: rustup

Rustを使い始めるには、まずRustツールチェインをインストールする必要があります。Rust公式は、rustupというツールを使用してRustをインストール・管理することを推奨しています。rustupは、異なるバージョンのRust（安定版、ベータ版、ナイトリー版）を簡単に切り替えたり、クロスコンパイルのためのターゲットを追加したり、開発に必要なコンポーネントを管理したりするための非常に便利なツールです。

2.1. rustup のインストール

rustupをインストールする最も一般的な方法は、公式サイト（rust-lang.org）に記載されているスクリプトを実行することです。

Linux / macOSの場合:

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

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

このコマンドは、rustupのインストールスクリプトをダウンロードして実行します。スクリプトは、インストールタイプ（デフォルトインストールかカスタマイズか）を尋ねてきます。初心者の方は、特にこだわりがなければデフォルトインストールを選択することをおすすめします。

インストールが完了すると、rustupはRustの安定版ツールチェインをダウンロードし、Rustコンパイラ（rustc）やCargo（cargo）などのツールをシステムのパスに追加します。これにより、どのターミナルからでもこれらのコマンドを実行できるようになります。

インストールスクリプトの最後に、環境変数を設定するための指示が表示される場合があります。通常は、以下の行をシェル設定ファイル（例: ~/.bashrc, ~/.zshrc）に追加するか、スクリプトが自動的に追加してくれます。

bash
source $HOME/.cargo/env

この行は、Cargoがインストールした実行ファイル（~/.cargo/bin ディレクトリに置かれることが多い）へのパスを通すためのものです。設定ファイルを編集した場合は、ターミナルを再起動するか、設定ファイルを再読み込み（例: source ~/.zshrc）することで変更が反映されます。

Windowsの場合:

Windowsの場合は、公式サイトからrustup-init.exeインストーラーをダウンロードして実行します。インストーラーの手順に従って進めれば、簡単にインストールできます。デフォルト設定でのインストールをおすすめします。MSVC版とGNU版がありますが、通常はMSVC版を選択します（Visual Studio Build Toolsが必要になる場合があります）。

インストールが完了したら、コマンドプロンプトやPowerShellを開き、rustc --versionとcargo --versionを実行して、RustとCargoが正しくインストールされているか確認してみましょう。バージョン情報が表示されれば成功です。

2.2. rustup の主要コマンド

rustup自体にも、いくつかの重要なコマンドがあります。これらはRustツールチェインを管理するために使われます。

  • rustup update: インストール済みのRustツールチェインを最新版に更新します。

    bash
    rustup update

    Rustは活発に開発されている言語であり、定期的に新しいバージョンがリリースされます。このコマンドを実行することで、常に最新の安定版や、利用しているベータ版/ナイトリー版にアップデートできます。

  • rustup show: 現在設定されているデフォルトのツールチェイン、インストールされているツールチェイン、有効なターゲットなどの情報を表示します。

    bash
    rustup show

    これは、現在どのバージョンのRustを使っているか、クロスコンパイルのターゲットが追加されているかなどを確認したい場合に役立ちます。

  • rustup default <toolchain>: 特定のツールチェイン（例: stable, beta, nightly、または特定のバージョン番号 1.60.0 など）をシステムのデフォルトとして設定します。

    bash
    rustup default stable
    rustup default nightly
    rustup default 1.60.0

    プロジェクトによっては、特定のバージョンのRustが必要になる場合があります。このコマンドを使えば、簡単にデフォルトのツールチェインを切り替えることができます。

  • rustup toolchain install <toolchain>: 特定のツールチェインをインストールします。

    bash
    rustup toolchain install beta
    rustup toolchain install nightly
    rustup toolchain install 1.60.0

    デフォルトでは安定版のみがインストールされますが、ベータ版やナイトリー版、あるいは過去の特定バージョンをインストールしたい場合にこのコマンドを使います。

  • rustup target add <target>: クロスコンパイルのために、特定のプラットフォーム（ターゲット）向けの標準ライブラリやコンポーネントを追加します。

    bash
    rustup target add x86_64-unknown-linux-gnu # Linux (x86_64)
    rustup target add i686-pc-windows-msvc # Windows 32-bit (MSVC)
    rustup target add armv7-unknown-linux-gnueabihf # ARMv7 Linux

    Rustで別のアーキテクチャやOS向けにコンパイル（クロスコンパイル）を行いたい場合に必要になります。利用可能なターゲットはrustup target listで確認できます。

  • rustup component add <component>: 開発に必要な追加コンポーネント（例: rustfmt, clippy）をインストールします。

    bash
    rustup component add rustfmt
    rustup component add clippy

    rustfmtはコードフォーマッター、clippyはLinterです。これらのツールはRust開発の効率とコード品質を向上させる上で非常に役立ちます。多くの場合はrustupのインストール時にデフォルトで含まれますが、もし含まれていない場合や、後から追加したい場合にこのコマンドを使います。

  • rustup uninstall: Rustツールチェインとrustup自身をシステムからアンインストールします。

    bash
    rustup uninstall

    Rustの使用をやめる場合や、完全にクリーンな状態から再インストールしたい場合に利用します。

rustupはRust開発環境の土台となるツールです。これらの基本的なコマンドを覚えておけば、Rustのインストール、更新、管理をスムーズに行えるでしょう。

3. プロジェクト管理とビルド: cargo

Rustエコシステムの心臓部とも言えるのが、cargoです。cargoはRustのビルドシステムであり、同時にパッケージマネージャーでもあります。新しいプロジェクトの作成から、依存関係の管理、コードのビルド、実行、テスト、ベンチマーク、ドキュメント生成など、開発ライフサイクルのほぼ全てに関わる非常に強力なツールです。

ほとんどのRust開発者は、rustcコマンドを直接使うよりも、cargoを通じてRustプログラムをビルド・実行します。これは、cargoが複雑なコンパイルオプションや依存関係の解決、ビルドキャッシュの管理などを自動で行ってくれるからです。

3.1. cargo new：新しいプロジェクトの作成

Rustプロジェクトを新しく始めるときは、通常cargo newコマンドを使います。このコマンドは、プロジェクトの基本的なディレクトリ構造と、必要な設定ファイル (Cargo.toml) を自動で生成してくれます。

bash
cargo new my-rust-project

このコマンドを実行すると、現在のディレクトリにmy-rust-projectという名前の新しいディレクトリが作成されます。そのディレクトリの中には、以下のファイルとサブディレクトリが生成されます。

my-rust-project/
├── Cargo.toml
└── src/
└── main.rs

  • Cargo.toml: これはCargoの設定ファイルです。プロジェクト名、バージョン、作者情報、そしてプロジェクトが依存する外部ライブラリ（クレートと呼ばれます）などが記述されます。これはRustプロジェクトにおいて非常に重要なファイルです。
  • src/ ディレクトリ: ソースコードを格納するためのディレクトリです。
  • src/main.rs: cargo newで生成されるデフォルトのソースファイルです。実行可能ファイル（バイナリ）プロジェクトの場合、このファイルにはプログラムのエントリーポイントとなるmain関数が含まれています。

バイナリプロジェクト vs ライブラリプロジェクト

cargo newはデフォルトでバイナリプロジェクトを作成します。これは、実行可能なプログラムをビルドするためのプロジェクトです。

もし、他のプロジェクトから利用されることを目的としたライブラリプロジェクトを作成したい場合は、--libオプションを付けます。

bash
cargo new my-rust-library --lib

この場合、生成されるプロジェクト構造は以下のようになります。

my-rust-library/
├── Cargo.toml
└── src/
└── lib.rs

  • src/lib.rs: ライブラリプロジェクトのメインソースファイルです。ライブラリとして公開したい関数や型などをここに記述します。

また、明示的にバイナリプロジェクトを作成したい場合は--binオプションを使いますが、cargo newはデフォルトでバイナリなので通常は省略されます。

実行例:

``bash
$ cargo new hello-world
Created binary (application)hello-world` package

$ cd hello-world/

$ tree
.
├── Cargo.toml
└── src
└── main.rs

1 directory, 2 files

$ cat Cargo.toml
[package]
name = “hello-world”
version = “0.1.0”
edition = “2021”

See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

$ cat src/main.rs
fn main() {
println!(“Hello, world!”);
}
“`

これで、最初のRustプロジェクトを作成できました。次に、このプロジェクトをビルドしてみましょう。

3.2. cargo build：プロジェクトのビルド

cargo buildコマンドは、現在のディレクトリまたは指定されたディレクトリにあるRustプロジェクトのソースコードをコンパイルし、実行可能なバイナリファイルやライブラリファイルを生成します。

プロジェクトディレクトリ（Cargo.tomlファイルがあるディレクトリ）に移動して、以下のコマンドを実行します。

bash
cargo build

このコマンドを実行すると、Cargoは以下の処理を行います。

  1. Cargo.tomlファイルを読み込み、プロジェクトの設定や依存関係を確認します。
  2. 依存している外部クレート（まだダウンロード・ビルドされていない場合）をダウンロードし、ビルドします。
  3. プロジェクト自身のソースコード（例: src/main.rs, src/lib.rs）をコンパイルします。
  4. 生成されたバイナリファイルやライブラリファイルを、プロジェクトディレクトリ内のtarget/debug/ディレクトリに配置します。

target/debug/ディレクトリ

Cargoは、ビルドされた成果物をtarget/というディレクトリに格納します。デフォルトのcargo buildコマンドは、デバッグビルドを実行するため、成果物はtarget/debug/サブディレクトリに置かれます。

デバッグビルドは、開発中のイテレーションを高速化するために最適化レベルが低く設定されており、デバッグ情報が含まれています。

--releaseオプション

本番環境へのデプロイや、パフォーマンスが重要な場面では、最適化レベルを高く設定したリリースビルドを行う必要があります。これには--releaseオプションを使用します。

bash
cargo build --release

このコマンドでビルドされた成果物は、target/release/ディレクトリに配置されます。リリースビルドはコンパイルに時間がかかりますが、生成されるバイナリは通常より高速に動作し、サイズも小さくなります。

実行例:

hello-worldプロジェクトディレクトリでcargo buildを実行します。

“`bash
$ cd hello-world/

$ cargo build
Compiling hello-world v0.1.0 (/path/to/hello-world)
Finished dev [unoptimized + debuginfo] target(s) in 0.xXs

$ tree target/debug/
target/debug/
├── build
├── deps
│ ├── hello_world-xxxxxxxxxxxxxxxxx
│ └── libhello_world-xxxxxxxxxxxxxxxxx.d
├── examples
├── hello-world # Windowsでは hello-world.exe
├── hello-world.d
├── incremental
└── native

8 directories, 3 files # ファイル数は環境により異なります
“`

target/debug/ディレクトリにhello-worldという実行ファイルが生成されているのがわかります（Windowsの場合はhello-world.exe）。この実行ファイルを直接実行することもできます。

bash
$ ./target/debug/hello-world
Hello, world!

3.3. cargo run：ビルドして実行

cargo runコマンドは、cargo buildを実行してから、ビルドされたバイナリを実行するという一連の流れを一度に行ってくれる便利なコマンドです。特にプログラムを頻繁に修正・実行して動作確認を行う開発段階でよく使われます。

bash
cargo run

このコマンドは、まずソースコードに変更がないか確認し、必要であればビルドを行います。その後、target/debug/ディレクトリにある実行ファイルを起動します。

リリースビルドを実行したい場合は、--releaseオプションを付けます。

bash
cargo run --release

この場合、target/release/ディレクトリにある実行ファイルが起動されます。

実行例:

hello-worldプロジェクトディレクトリでcargo runを実行します。

“`bash
$ cd hello-world/

$ cargo run
Compiling hello-world v0.1.0 (/path/to/hello-world)
Finished dev [unoptimized + debuginfo] target(s) in 0.xXs
Running target/debug/hello-world
Hello, world!
“`

もしソースコードに変更がなければ、ビルドはスキップされ、すぐに実行されます。

bash
$ cargo run # ソースコードに変更なし
Finished dev [unoptimized + debuginfo] target(s) in 0.0Xs
Running `target/debug/hello-world`
Hello, world!

引数を渡す

実行するプログラムにコマンドライン引数を渡したい場合は、cargo run -- の後に引数を記述します。--は、それ以降がcargo run自身のオプションではなく、実行されるプログラムへの引数であることをCargoに伝えるための区切り記号です。

例えば、引数を受け取って表示する簡単なRustプログラムがあるとします。

“`rust
// src/main.rs
use std::env;

fn main() {
let args: Vec = env::args().collect();
println!(“Passed arguments: {:?}”, args);
}
“`

このプログラムをcargo runで実行し、引数arg1とarg2を渡したい場合：

bash
$ cargo run -- arg1 arg2
Compiling my-project v0.1.0 (/path/to/my-project)
Finished dev [unoptimized + debuginfo] target(s) in 0.xXs
Running `target/debug/my-project arg1 arg2`
Passed arguments: ["target/debug/my-project", "arg1", "arg2"]

最初の引数は常に実行ファイル自身のパスになります。

cargo runは、開発中の反復作業において最も頻繁に使用するコマンドの一つとなるでしょう。

3.4. cargo check：コードの高速チェック

cargo checkコマンドは、ソースコードをコンパイルしますが、実行可能なバイナリやライブラリは生成しません。その代わり、コンパイルプロセスの中で行われる構文チェック、型チェック、借用チェックなどのエラーや警告だけを報告します。

bash
cargo check

なぜこのようなコマンドが必要なのでしょうか？ 完全なビルド（cargo build）は、コード生成や最適化のステップを含むため、特に大きなプロジェクトでは時間がかかります。開発中にコードを少し変更するたびにフルビルドを実行するのは非効率です。

cargo checkは、ビルドの比較的時間がかかる部分（コード生成など）をスキップすることで、cargo buildよりもはるかに高速に実行できます。これにより、コードを記述している最中に、構文エラーや型エラーがないか、借用規則に違反していないかなどを素早く確認できます。

開発ワークフローにおいては、コードを少し書いたらcargo checkでエラーがないか確認し、大きな区切りがついた段階やリリース前にcargo buildやcargo runで最終確認を行う、という流れが効率的です。

実行例:

hello-worldプロジェクトでcargo checkを実行します。

“`bash
$ cd hello-world/

$ cargo check
Checking hello-world v0.1.0 (/path/to/hello-world)
Finished dev [unoptimized + debuginfo] target(s) in 0.xXs
“`

もしコードにエラーがある場合、cargo checkはエラーメッセージと発生箇所を表示します。

例えば、src/main.rsを以下のように変更して、セミコロンを忘れてみます。

rust
fn main() {
println!("Hello, world!") // セミコロンがない
}

``bash
$ cargo check
Checking hello-world v0.1.0 (/path/to/hello-world)
error: expected;, found}--> src/main.rs:3:1
|
3 | }
| ^ expected;`

error: could not compile hello-world due to previous error
“`

このように、ビルドせずにエラーを素早く検出できるため、cargo checkは非常に便利なコマンドです。IDEやエディタの多くは、保存時に自動的にcargo checkを実行してリアルタイムでエラーをフィードバックする機能を持っています。

3.5. cargo test：テストの実行

Rustは言語レベルでテスト機能をサポートしており、cargo testコマンドはそのテストコードを実行するためのツールです。品質の高いソフトウェア開発にはテストが不可欠であり、Rustではテストコードを本番コードと同じファイル内に記述したり、専用のtests/ディレクトリに記述したりできます。

bash
cargo test

このコマンドを実行すると、Cargoはプロジェクト内のテストコードを探し出し、コンパイルして実行します。テストが成功したか失敗したかの結果が表示されます。

テストコードの基本的な書き方

Rustでは、関数に#[test]アトリビュートを付けることでテスト関数として定義します。

“`rust
// src/lib.rs (ライブラリの場合) または src/main.rs (バイナリの場合)

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

[cfg(test)] // test設定が有効な時のみコンパイルされる

mod tests {
use super::*; // 親モジュールの要素をインポート

#[test] // これがテスト関数であることを示すアトリビュート
fn test_add() {
    assert_eq!(add(2, 3), 5); // 結果が期待通りかアサート
}

#[test]
fn test_add_negative() {
    assert_eq!(add(-1, 1), 0);
}

#[test]
#[should_panic] // パニックが発生することを期待するテスト
fn test_panic() {
    panic!("意図的なパニック");
}

}
“`

実行例:

上記のテストコードを含むプロジェクトでcargo testを実行します。

“`bash
$ cargo test
Compiling my-project v0.1.0 (/path/to/my-project)
Finished test [unoptimized + debuginfo] target(s) in 0.xXs
Running unittests (target/debug/deps/my_project-xxxxxxxxxxxxxxxxx)

running 3 tests
test tests::test_add … ok
test tests::test_add_negative … ok
test tests::test_panic … ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.0Xs
“`

テストがすべて成功したことがわかります。

特定のテストを実行する

テスト関数名の一部や、モジュール名を引数として渡すことで、特定のテストだけを実行できます。

bash
cargo test test_add # "test_add"を含むテストを実行
cargo test test_add_negative # "test_add_negative"を含むテストを実行
cargo test tests::test_add # "tests"モジュール内の"test_add"を実行

cargo testは、開発の早い段階で問題を発見し、コードの変更が既存の機能に影響を与えていないかを確認するために非常に重要なコマンドです。

3.6. cargo clean：ビルド成果物の削除

cargo cleanコマンドは、target/ディレクトリとその中身を削除します。これは、以前のビルドによって生成されたファイル（実行ファイル、ライブラリ、中間ファイルなど）を全て削除し、クリーンな状態に戻したい場合に役立ちます。

bash
cargo clean

なぜこれが必要なのでしょうか？

  • 容量の解放: ビルドプロセスは多くのファイル（特に中間ファイルやデバッグ情報を含むファイル）を生成するため、target/ディレクトリはすぐに数百MB、あるいはそれ以上の容量を消費することがあります。容量が気になる場合にcargo cleanで一時的に解放できます。
  • クリーンな再ビルド: まれに、過去のビルドキャッシュや中間ファイルが原因で予期しないビルドエラーが発生することがあります。そのような場合、cargo cleanでクリーンアップしてから再ビルドすることで問題が解決することがあります。

cargo cleanは、日常的な開発で頻繁に使うコマンドではありませんが、上記のような状況で役立ちます。

実行例:

ビルド後にtarget/ディレクトリが存在する状態でcargo cleanを実行します。

“`bash
$ cd hello-world/

$ cargo build # まずビルドしてtargetディレクトリを作成
Compiling hello-world v0.1.0 (/path/to/hello-world)
Finished dev [unoptimized + debuginfo] target(s) in 0.xXs

$ ls target/
debug/ .rustc_info.json

$ cargo clean
Removing /path/to/hello-world/target

$ ls target/ # targetディレクトリ自体は残るが、中身は削除される
“`

3.7. cargo update：依存クレートの更新

cargoは依存関係を管理するパッケージマネージャーでもあります。プロジェクトが依存する外部ライブラリ（クレート）は、Cargo.tomlファイルの[dependencies]セクションに記述します。

toml
[dependencies]
rand = "0.8" # 例：乱数生成クレート
serde = { version = "1.0", features = ["derive"] } # 例：シリアライズ/デシリアライズクレート

cargo buildやcargo runを実行すると、CargoはCargo.tomlを読み込み、必要な依存クレートを自動的にダウンロードしてコンパイルします。ダウンロードされたクレートは、通常グローバルなキャッシュディレクトリ（~/.cargo/registry/など）に保存されます。

cargo updateコマンドは、プロジェクトの依存クレートを、Cargo.tomlで指定されたバージョン要件を満たす最新のバージョンに更新します。

bash
cargo update

このコマンドを実行すると、Cargoは各依存クレートについて、Cargo.tomlで指定されたバージョン範囲内でcrates.io（Rustの公式クレートリポジトリ）にある最新バージョンを確認し、必要であればダウンロードしてキャッシュを更新します。そして、実際にどのバージョンのクレートが使用されるかを記録したCargo.lockファイルを更新します。

Cargo.lockファイル

プロジェクトのルートディレクトリには、Cargo.lockというファイルも存在します。このファイルは、そのプロジェクトがビルドされた際に、実際に使用された依存クレートの正確なバージョンを記録しています。

Cargo.tomlは「このバージョン範囲のクレートを使いたい」という希望を書くのに対し、Cargo.lockは「実際にこのバージョンを使った」という事実を記録します。これにより、プロジェクトを別の環境でビルドしても、Cargo.lockがあれば全く同じ依存クレートの組み合わせでビルドされることが保証されます。これは、ビルドの再現性を確保するために非常に重要です。

通常、アプリケーション開発ではCargo.lockファイルもGitなどのバージョン管理システムにコミットします。これにより、チームメンバー全員が同じ依存関係のセットで開発できます。ライブラリ開発の場合は、依存元のアプリケーションがライブラリのバージョンを選ぶため、Cargo.lockはコミットしないのが一般的です。

cargo updateは、開発中に依存クレートの新しい機能を使いたい場合や、バグ修正/セキュリティアップデートを取り込みたい場合に実行します。ただし、依存クレートのメジャーバージョンアップは破壊的な変更を含む可能性があるため、cargo updateを実行した後は慎重にテストを行う必要があります。

3.8. cargo add / cargo remove：依存クレートの追加・削除

プロジェクトに新しい依存クレートを追加したり、不要になったクレートを削除したりする際に便利なのが、cargo addとcargo removeコマンドです。これらのコマンドは、Cargo.tomlファイルを自動的に編集してくれます。

cargo add <crate_name>

bash
cargo add rand

このコマンドは、crates.ioからrandクレートの最新バージョン（Cargo.tomlの指定方法に従って互換性のある最新版）を検索し、Cargo.tomlファイルの[dependencies]セクションに自動的に追加します。

toml
[dependencies]
rand = "0.8.5" # 例：実行時の最新バージョンが追加される

特定のバージョンや、特定の機能（features）を指定して追加することもできます。

bash
cargo add [email protected] --features derive
cargo add tokio --version 1.20 --features full

開発依存（テストやビルドスクリプトなどでだけ使うクレート）として追加したい場合は--devオプションを付けます。

bash
cargo add criterion --dev # ベンチマーク用クレートなどを追加

ビルド依存（ビルドプロセス中にだけ使うクレート、例: コード生成など）として追加したい場合は--buildオプションを付けます。

bash
cargo add bindgen --build

cargo remove <crate_name>

bash
cargo remove rand

このコマンドは、Cargo.tomlファイルの[dependencies]セクションから指定したクレートのエントリを削除します。

これらのコマンドは、手動でCargo.tomlを編集する手間を省き、入力ミスを防ぐことができるため、非常に便利です。特に初心者の方は、クレートの追加・削除にこのコマンドを使うことをおすすめします。

3.9. cargo fmt：コードフォーマット

Rustコミュニティには、公式に推奨されているコーディングスタイルがあります。cargo fmtコマンドは、プロジェクトのソースコードをこの推奨スタイルに従って自動的にフォーマットします。

bash
cargo fmt

このコマンドを実行すると、プロジェクト内の.rsファイルを走査し、標準のRustスタイルガイドに従ってコードのインデント、スペース、改行などを整形します。

なぜコードフォーマットが重要なのか？

  • 可読性の向上: スタイルが統一されていると、他の人が書いたコードや過去の自分のコードが読みやすくなります。
  • 共同開発の効率化: チームで開発する際に、スタイルに関する議論や手動での修正の手間を省き、コードレビューの焦点を内容そのものに絞ることができます。
  • コード品質の維持: 整形されたコードは、構文エラーや構造的な問題を早期に発見しやすくなることがあります。

cargo fmtは、rustfmtというツールを実行しています。通常、rustupのインストール時にrustfmtも一緒にインストールされるので、すぐにcargo fmtを使えます。

オプション:

  • --all: ワークスペース内の全てのパッケージに対して実行します（ワークスペースを使っている場合）。
  • --check: コードをフォーマットせずに、整形が必要な箇所があるかチェックするだけを行います。CI（継続的インテグレーション）などで、コードが適切にフォーマットされているかを確認するのに便利です。

bash
cargo fmt --check # フォーマットが必要なファイルがあればエラー終了

開発ワークフローにcargo fmt（またはエディタの自動フォーマット機能）を取り入れることで、常に整形された美しいコードを保つことができます。

3.10. cargo clippy：Linterの実行

cargo clippyコマンドは、RustのLinter（静的解析ツール）であるClippyを実行します。Clippyは、コンパイラが検出するエラーや警告に加えて、より多くの種類の潜在的な問題点や改善点を指摘してくれます。

bash
cargo clippy

Clippyは、パフォーマンスの低下、コードの可読性の低下、慣用的でないRustコード、潜在的なバグにつながる可能性のあるパターンなど、幅広い種類の「lint」（指摘）を行います。

例えば、以下のようなコードがあったとします。

rust
fn main() {
let x = 5;
if x == 5 { // == 5 という直接的な比較はClippyが指摘する可能性がある
println!("x is five");
}
}

Clippyを実行すると、このようなコードに対してよりRustらしい、あるいは安全な書き方を提案してくれることがあります（例: if x == 5ではなく、パターンマッチを使うなど）。

なぜClippyを使うのか？

  • コード品質の向上: ベストプラクティスに従っていないコードや、潜在的な問題を指摘してくれることで、より堅牢でメンテナブルなコードを書くのに役立ちます。
  • 学習: Clippyの指摘を通して、Rustの慣用句や効率的な書き方について学ぶことができます。
  • バグの早期発見: コンパイルは通るが実行時に問題を引き起こす可能性のあるコードパターンを検出できることがあります。

cargo clippyもrustupでインストールされるコンポーネントとして提供されます。

実行例:

``bash
$ cargo clippy
Checking my-project v0.1.0 (/path/to/my-project)
warning: using==on a double literal
--> src/main.rs:2:11
|
2 | if x == 5.0 {
| ^^
|
= help: consider comparing within a small range of tolerance instead
= note:#[warn(clippy::float_cmp)]` on by default

warning: my-project (bin “my-project”) generated 1 warning (run cargo clippy --fix to apply 1 suggestion)
Finished dev [unoptimized + debuginfo] target(s) in 0.xXs
“`

Clippyは多くの種類のlintを持っており、それぞれ警告レベルが設定されています。プロジェクトの設定ファイル（.clippy.tomlやCargo.toml）で、特定のlintを無視したり、警告レベルを変更したりすることも可能です。

cargo clippy --fixコマンドを使うと、Clippyが提案する修正の一部を自動的に適用することができます。

cargo fmtと同様に、cargo clippyも開発ワークフローやCIに組み込むことで、継続的にコード品質を向上させることができます。

3.11. cargo doc：ドキュメント生成

Rustは、ソースコード内の特別なコメント（ドキュメンテーションコメント）からHTML形式のドキュメントを生成する機能を言語レベルでサポートしています。cargo docコマンドは、この機能を利用してプロジェクトのドキュメントを生成します。

bash
cargo doc

このコマンドを実行すると、ソースコード内の///や//!で始まるドキュメンテーションコメントを解析し、target/doc/ディレクトリ内にHTML形式のドキュメントを生成します。生成されたドキュメントを開くと、プロジェクトのAPIリファレンスなどをブラウザで閲覧できます。

ドキュメンテーションコメントの基本的な書き方

RustのドキュメンテーションコメントはMarkdown記法で記述でき、コード例を含めることも可能です。

rust
/// Adds two integers and returns the result.
///
/// # Arguments
///
/// * `a` - The first integer.
/// * `b` - The second integer.
///
/// # Examples
///
///
/// let sum = my_crate::add(2, 2);
/// assert_eq!(sum, 4);
/// pub fn add(a: i32, b: i32) -> i32 {
a + b
}

  • ///: 関数の定義や構造体、Enumなどのアイテムに直接関連するドキュメント。
  • //!: モジュール全体やクレート全体の説明など、親アイテムに関連するドキュメント（通常src/lib.rsやsrc/main.rsの先頭に書かれる）。

実行例:

上記のドキュメンテーションコメントを含むプロジェクトでcargo docを実行します。

bash
$ cargo doc
Compiling my-project v0.1.0 (/path/to/my-project)
Finished dev [unoptimized + debuginfo] target(s) in 0.xXs
Documenting my-project v0.1.0 (/path/to/my-project)
Finished dev [unoptimized + debuginfo] target(s) in 0.xXs

ドキュメントが生成されたら、target/doc/<project_name>/index.htmlファイルを開くことで閲覧できます。便利なオプションとして、cargo doc --openを使うと、ドキュメント生成後に自動的にブラウザで開いてくれます。

bash
cargo doc --open

高品質なドキュメントは、自分自身が後でコードを見返したり、他の人にコードを使ってもらったりする上で非常に重要です。Rustのドキュメンテーション機能とcargo docコマンドを積極的に活用しましょう。

3.12. その他の便利な cargo コマンド

cargoには上記以外にも多くのコマンドがあります。いくつかよく使われるものを紹介します。

  • cargo publish: 自分で作成したクレートをcrates.ioに公開します。これにはcrates.ioアカウントの取得や設定が必要です。

    bash
    cargo publish

    注意: これはクレートを全世界に公開するコマンドなので、テスト目的で安易に実行しないように注意してください。

  • cargo bench: ベンチマークテストを実行します。コードのパフォーマンスを測定する際に使用します。これにはテストと同様に特定の書き方でベンチマークコードを記述する必要があります。

    bash
    cargo bench

  • cargo build --target <target>: 特定のターゲット（プラットフォーム）向けにクロスコンパイルを行います。事前にrustup target add <target>でターゲットを追加しておく必要があります。

    bash
    cargo build --target x86_64-unknown-linux-gnu

  • cargo fmt --check --all: ワークスペース全体でコードが適切にフォーマットされているかチェックします。CIでよく使用されます。

  • cargo clippy --fix: Clippyが検出した指摘の一部を自動的に修正します。

  • cargo init: 既存のディレクトリにRustプロジェクトを作成します。cargo newは新しいディレクトリを作成しますが、cargo initは既存のディレクトリ内にCargo.tomlとsrc/ディレクトリを作成します。

    bash
    mkdir my-existing-project
    cd my-existing-project
    cargo init

これらのコマンドは、Rust開発の様々な側面をサポートし、効率的な開発を可能にします。必要に応じてCargoの公式ドキュメントを参照すると、さらに多くのコマンドやオプションを見つけることができます。

4. その他の便利なコマンド/ツール

rustupとcargoがRust開発の中心的なコマンドですが、他にも知っておくと便利なツールや、開発ワークフローに関連するツールがあります。

4.1. rustc：Rustコンパイラ

rustcはRust言語の公式コンパイラです。cargo buildやcargo runといったCargoコマンドは、内部的にこのrustcコマンドを呼び出してソースコードをコンパイルしています。

通常、Cargoを使う限りrustcコマンドを直接使う必要はありません。しかし、単一のソースファイルだけをコンパイルして試したい場合や、Cargoが内部でどのように動作しているか理解したい場合には、rustcを直接使うことができます。

単一ファイルのコンパイル例:

以下の内容でhello.rsというファイルを作成します。

rust
// hello.rs
fn main() {
println!("Hello from rustc!");
}

このファイルをrustcでコンパイルします。

bash
rustc hello.rs

成功すると、カレントディレクトリにhelloという実行ファイル（Windowsではhello.exe）が生成されます。これを実行します。

bash
./hello # Windowsでは hello.exe
Hello from rustc!

rustcコマンドには非常に多くのオプションがありますが、通常はCargoが最適なオプションを選択して実行してくれます。初心者の方は、rustcが存在することと、Cargoがそれを利用していることを知っておけば十分です。

4.2. IDE/エディタとの連携 (rust-analyzerなど)

直接コマンドとして実行するものではありませんが、Rust開発の体験を大きく向上させるのが、LSP（Language Server Protocol）サーバーであるrust-analyzerです。多くのモダンなIDEやエディタ（VS Code, Sublime Text, Neovimなど）はLSPをサポートしており、rust-analyzerをインストールして設定することで、以下の機能が利用可能になります。

  • コード補完
  • 定義へ移動 (Go to Definition)
  • 参照の検索 (Find References)
  • 型情報の表示 (Hover)
  • エラーと警告のリアルタイム表示 (裏でcargo checkを実行していることが多い)
  • コードフォーマット（保存時にcargo fmtを実行）
  • ClippyによるLint指摘の表示（裏でcargo clippyを実行）
  • リファクタリング支援

rust-analyzerは、通常IDEやエディタの拡張機能としてインストール・設定します。rustupを使ってインストールできる場合もあります。開発効率を劇的に向上させるため、Rust開発にはIDE/エディタとrust-analyzerの連携が強く推奨されます。

4.3. デバッガ

プログラムの実行中に問題が発生した場合、その原因を特定するためにデバッガが役立ちます。Rust自体には独自のデバッガはありませんが、C/C++開発で使われる既存のデバッガ（Linux/macOSではGDBやLLDB、WindowsではWinDbgやVisual Studio Debuggerなど）を利用できます。

Cargoが生成するデバッグビルド (cargo build) には、デバッガが利用するためのデバッグ情報が含まれています。デバッガを使ってRustプログラムをデバッグするには、通常以下の手順を踏みます。

  1. cargo buildでデバッグビルドを行う。
  2. 生成された実行ファイル（target/debug/<binary_name>）をデバッガで開く。
  3. ブレークポイントを設定し、プログラムを実行する。

IDEやエディタによっては、デバッガとの連携機能を提供しているものもあります（例: VS CodeのRust拡張機能）。これにより、IDE上から直接デバッグセッションを開始できます。

デバッガの使い方は各デバッガによって異なりますが、Rustの変数や構造体などの情報を表示できるよう、特定のプラグインや設定が必要になる場合があります。これは少し高度なトピックですが、開発が進むにつれてデバッグ能力の重要性を感じるようになるでしょう。

5. コマンドのヘルプと補完

この記事では主要なコマンドを解説しましたが、それぞれのコマンドにはさらに多くのオプションがあります。コマンドの詳しい使い方やオプションを知りたい場合は、ヘルプ機能を利用するのが最も手軽な方法です。

  • --help オプション: ほとんどのコマンドは、引数なしで実行するか、--helpオプションを付けて実行することで、簡単な使い方や主要なオプション一覧を表示します。

    bash
    rustup --help
    cargo --help
    cargo build --help
    rustc --help

    特定のサブコマンド（例: cargo build）のヘルプを見たい場合は、そのサブコマンド名の後に--helpを付けます。

  • man コマンド: システムにmanページがインストールされていれば、man <command_name>で詳細なマニュアルページを参照できる場合があります。

    bash
    man cargo

    ただし、Rust関連のコマンドのmanページは、すべてのシステムにデフォルトでインストールされているわけではありません。

シェル補完

コマンドラインでの作業効率を上げるために、シェルの補完機能を設定することをおすすめします。これにより、コマンド名やファイルパス、オプションなどをTabキーで自動入力できるようになります。

rustupは、主要なシェル（bash, zsh, Fishなど）向けの補完スクリプトを生成する機能を持っています。

bash
rustup completions <shell_name>

例えば、bashの場合は以下のコマンドで補完スクリプトを生成し、設定ファイルに追記します（シェルの設定方法は環境によって異なります）。

bash
rustup completions bash >> ~/.bashrc

設定を反映させるには、ターミナルを再起動するか、設定ファイルを再読み込みします。これにより、rustupやcargoコマンドを入力する際にTabキーで候補が表示されるようになり、タイプミスを減らし、コマンド入力を高速化できます。

6. 開発ワークフローにおけるコマンドの役割

Rustでの典型的な開発ワークフローにおける主要コマンドの役割をまとめてみましょう。

  1. プロジェクトの開始: cargo new <project_name>で新しいプロジェクトを作成します。
  2. 依存関係の追加: cargo add <crate_name>で必要な外部クレートを追加します。
  3. コードの記述: エディタ/IDEでソースコード（src/main.rsやsrc/lib.rsなど）を記述します。IDEとrust-analyzerを連携させている場合、記述中にリアルタイムでエラーや警告が表示されます。
  4. コードのチェック: 定期的にcargo checkを実行して、構文エラーや型エラーがないか素早く確認します。IDE連携していれば、保存時に自動実行されます。
  5. ビルド: コードがある程度完成したら、cargo buildでプロジェクト全体をビルドし、実行ファイルやライブラリを生成します。リリース目的の場合はcargo build --releaseを使います。
  6. 実行: cargo runまたはcargo run --releaseでプログラムを実行して動作を確認します。必要に応じてコマンドライン引数を渡します (cargo run -- <args>)。
  7. テスト: 機能が完成したら、cargo testでテストを実行し、期待通りの動作をするか確認します。新しい機能を追加したら、それに対応するテストコードも記述します。
  8. コード品質の向上: cargo fmtでコードを整形し、コーディングスタイルを統一します。cargo clippyでLinterを実行し、潜在的な問題点や改善点をチェックします。
  9. ドキュメント生成: cargo docでドキュメントを生成し、公開可能な形式でAPIリファレンスを作成します。
  10. 依存関係の管理: cargo updateで依存クレートを更新し、Cargo.lockファイルを最新の状態に保ちます。

これらのコマンドを使いこなすことで、Rust開発を効率的かつ体系的に進めることができます。

7. よくある疑問とトラブルシューティング

初心者の方がRustコマンドを使う上で遭遇しやすい問題とその解決策をいくつか紹介します。

7.1. command not found: cargo または command not found: rustc

原因: Rustツールチェイン（rustup, cargo, rustcなど）へのパスがシステムの環境変数に正しく設定されていない可能性があります。

解決策:

  1. rustupをインストールした際に表示された環境変数の設定指示に従っているか確認します。通常はsource $HOME/.cargo/envのような行をシェルの設定ファイル（~/.bashrc, ~/.zshrc, etc.）に追加し、設定を再読み込み（source ~/.bashrcなど）するかターミナルを再起動する必要があります。
  2. Windowsの場合は、インストーラーが自動で環境変数を設定しますが、手動で確認・追加する必要がある場合もあります。%USERPROFILE%\.cargo\binなどがPath環境変数に含まれているか確認してください。
  3. rustup showコマンドが実行できるか確認します。rustup自体が実行できない場合は、rustupのインストールからやり直す必要があるかもしれません。

7.2. ビルドエラーが発生した

原因: ソースコードに構文エラー、型エラー、借用チェック違反などがある場合に発生します。

解決策:

  1. エラーメッセージをよく読む: Rustコンパイラは非常に親切で、エラーメッセージには問題の箇所（ファイル名と行番号）と、エラーの種類、そして多くの場合、問題を解決するための「help」や「note」といったヒントが含まれています。
  2. エラーメッセージの最初から順番に見ていくことが重要です。最初のエラーが原因で、それ以降に無関係なエラーが連鎖的に発生することがあります。
  3. 特に借用チェック関連のエラーは初心者にとって理解が難しい場合があります。エラーメッセージに含まれるライフタイムや所有権に関する説明を注意深く読み、Rustの所有権システムに関するドキュメントを参照すると良いでしょう。
  4. cargo checkを頻繁に実行して、エラーを早期に検出・修正する習慣をつけましょう。

7.3. 依存関係のコンフリクト

原因: プロジェクトや依存クレートが、同じ別のクレートの異なる互換性のないバージョンに依存している場合に発生することがあります。

解決策:

  1. Cargoはセマンティックバージョニング（SemVer）に基づいて依存関係を解決しますが、複雑な依存ツリーでは解決できないコンフリクトが発生することがあります。
  2. cargo updateを実行して、Cargo.tomlのバージョン範囲内で最新の依存関係を試します。これにより、コンフリクトが解消される場合があります。
  3. cargo treeコマンドを使うと、プロジェクトの依存関係ツリーを確認できます。どのクレートがどのバージョンの依存クレートを要求しているかを把握するのに役立ちます。
  4. どうしても解決できない場合は、Cargo.tomlで特定の依存クレートのバージョンをより厳密に指定したり、Cargoの高度な機能（例: [patch]セクション）を使用したりする必要が出てくる場合があります。これは少し進んだトピックです。

7.4. ビルドが遅い

原因: 特に初回ビルドやリリースビルドは時間がかかります。依存クレートが多い場合や、PCの性能が低い場合もビルドが遅くなることがあります。

解決策:

  1. 開発中はcargo buildよりも高速なcargo checkやcargo runを積極的に利用します。cargo runは変更があった部分だけを再ビルドします。
  2. デバッグビルド (cargo build) は最適化レベルが低いため比較的速いですが、リリースビルド (cargo build --release) は高い最適化レベルのため時間がかかります。目的に応じて使い分けましょう。
  3. 増分コンパイルが有効になっているか確認します（通常デフォルトで有効です）。これにより、変更されたファイルとその依存ファイルだけが再コンパイルされ、以降のビルドが高速になります。
  4. SSDを使用しているか確認します。コンパイラは多数のファイルを読み書きするため、I/O速度がビルド時間に大きく影響します。
  5. CI/CD環境でビルドする場合は、ビルドキャッシュを活用することで時間を短縮できます。

これらの問題は、Rust開発を進める中で自然と遭遇し、経験とともに解決できるようになります。公式ドキュメントやコミュニティの情報を参考にしながら、一つずつ解決していくことが大切です。

8. まとめ

この記事では、Rust開発における主要なコマンドラインツール、特にrustupとcargoに焦点を当て、それぞれの目的、基本的な使い方、そして開発ワークフローにおける役割を詳細に解説しました。

  • rustup: Rustツールチェインのインストール、更新、管理を行うためのツールです。異なるバージョンのRustを切り替えたり、クロスコンパイルターゲットを追加したりできます。
  • cargo: Rustのビルドシステムでありパッケージマネージャーです。新しいプロジェクトの作成 (cargo new)、依存関係の管理 (Cargo.toml, Cargo.lock, cargo add, cargo remove, cargo update)、コードのビルド (cargo build)、実行 (cargo run)、高速チェック (cargo check)、テスト (cargo test)、コードフォーマット (cargo fmt)、Linter (cargo clippy)、ドキュメント生成 (cargo doc) など、開発のほぼ全ての側面をカバーします。
  • rustc: Rustコンパイラ本体ですが、通常はcargoを通じて間接的に利用します。

これらのコマンドはRust開発の基盤となります。最初は覚えることが多いと感じるかもしれませんが、実際に手を動かしてコードを書き、コマンドを繰り返し使っていくうちに自然と慣れていきます。

この記事で学んだコマンドをマスターすれば、Rustでの開発を自信を持って進めることができるでしょう。さらに深く学びたい場合は、Cargoの公式ドキュメント（doc.rust-lang.org/cargo/）を参照したり、より高度なCargoの機能（ワークスペース、ターゲット固有の依存関係、ビルドスクリプトなど）について学んでいくと良いでしょう。

Rustコミュニティは非常に協力的であり、もし困ったことがあれば、公式フォーラムやDiscordサーバー、Stack Overflowなどで質問してみるのも良い方法です。

さあ、これらの強力なツールを使って、Rustでの素晴らしいプログラミング体験を始めてください！

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール