Rust チートシート
最終更新
Hello World と構造
Rust プログラムは fn main から始まり、文はセミコロンで終わります。
| 操作 | 構文 |
|---|---|
| エントリポイント | fn main() { ... } |
| 1 行を出力 | println!("Hello, World!"); |
| 値を入れて出力 | println!("{} is {}", name, age); |
| デバッグ形式で出力 | println!("{:?}", value); |
| 行コメント | // comment |
| モジュールから項目を使う | use std::collections::HashMap; |
| ビルドして実行 | cargo run |
| リリースバイナリをビルド | cargo build --release |
変数と型 (let / mut)
束縛は既定で不変です。再代入を許すには mut を付けます。
| 操作 | 構文 |
|---|---|
| 不変の束縛 | let x = 5; |
| 可変の束縛 | let mut count = 0; |
| 明示的な型 | let age: u32 = 30; |
| 定数 | const MAX: u32 = 100; |
| シャドーイング | let x = x + 1; |
| 整数型 | i32, u32, i64, usize |
| その他のスカラー | f64, bool, char |
| タプル | let pair: (i32, &str) = (1, "a"); |
| 型変換 | let f = x as f64; |
制御フロー
if は式で、Rust にはループの形が 3 種類あります。
| 操作 | 構文 |
|---|---|
| if / else | if x > 0 { ... } else { ... } |
| 式としての if | let y = if x > 0 { 1 } else { -1 }; |
| 無限ループ | loop { ... } |
| 値を返すループ | let v = loop { break 5; }; |
| while ループ | while x < 100 { ... } |
| 範囲を for | for i in 0..10 { ... } |
| コレクションを for | for item in &items { ... } |
| break / continue | break;, continue; |
関数
最後の式 (セミコロンなし) が戻り値になります。
| 操作 | 構文 |
|---|---|
| 基本的な関数 | fn add(a: i32, b: i32) -> i32 { a + b } |
| 明示的な return | fn f() -> i32 { return 5; } |
| 戻り値なし | fn log(msg: &str) { ... } |
| 参照を取る | fn len(s: &String) -> usize { s.len() } |
| クロージャ | let add = |a, b| a + b; |
| 型付きクロージャ | let sq = |x: i32| -> i32 { x * x }; |
| 引数としての関数 | fn apply(f: impl Fn(i32) -> i32) { ... } |
所有権と借用
各値には所有者が 1 つあり、参照は所有権を取らずに値を借用します。
| 操作 | 構文 |
|---|---|
| ムーブ (所有権が移る) | let b = a; (a はもう有効でない) |
| クローン (ディープコピー) | let b = a.clone(); |
| 不変の借用 | let r = &x; |
| 可変の借用 | let r = &mut x; |
| 関数内での借用 | fn read(s: &String) { ... } |
| 間接参照 | *r |
| 借用のルール | 同時に複数の &、または 1 つの &mut。両方は不可 |
| スライス (範囲を借用) | let part = &arr[1..3]; |
構造体と列挙型
構造体は関連するデータをまとめ、列挙型は複数のバリアントのいずれかである値を表します。
| 操作 | 構文 |
|---|---|
| 構造体を定義 | struct Point { x: i32, y: i32 } |
| インスタンスを生成 | let p = Point { x: 1, y: 2 }; |
| フィールドにアクセス | p.x |
| タプル構造体 | struct Pair(i32, i32); |
| メソッド (impl ブロック) | impl Point { fn dist(&self) -> f64 { ... } } |
| 関連関数 | impl Point { fn new() -> Self { ... } } |
| 列挙型を定義 | enum Shape { Circle(f64), Rect(f64, f64) } |
| 名前付きフィールドの列挙型 | enum Msg { Move { x: i32, y: i32 } } |
| トレイトを derive | #[derive(Debug, Clone)] |
パターンマッチング (match)
match は値をパターンと照合し、網羅的でなければなりません。
| 操作 | 構文 |
|---|---|
| 値でマッチ | match x { 1 => "one", _ => "other" } |
| 列挙型でマッチ | match shape { Shape::Circle(r) => ... } |
| 範囲でマッチ | match n { 1..=5 => ..., _ => ... } |
| ガード付きで束縛 | match x { n if n > 0 => ... } |
| タプルでマッチ | match point { (0, y) => ..., (x, _) => ... } |
| if let (単一パターン) | if let Some(v) = opt { ... } |
| while let | while let Some(v) = stack.pop() { ... } |
| 構造体を分解 | let Point { x, y } = p; |
トレイトとジェネリクス
トレイトは共有された振る舞いを定義し、ジェネリクスはコードを多くの型で動くようにします。
| 操作 | 構文 |
|---|---|
| トレイトを定義 | trait Area { fn area(&self) -> f64; } |
| トレイトを実装 | impl Area for Circle { fn area(&self) -> f64 { ... } } |
| デフォルトメソッド | trait Greet { fn hi(&self) { ... } } |
| ジェネリック関数 | fn largest<T: PartialOrd>(list: &[T]) -> &T { ... } |
| ジェネリック構造体 | struct Wrapper<T> { value: T } |
| トレイト境界 (where) | fn f<T>(x: T) where T: Display { ... } |
| impl Trait 引数 | fn print(item: impl Display) { ... } |
| トレイトオブジェクト | let shapes: Vec<Box<dyn Area>> = ...; |
エラー処理 (Result / Option)
Rust は値の不在を Option で、回復可能なエラーを Result で表します。
| 操作 | 構文 |
|---|---|
| オプショナルな値 | Option<T>: Some(v) または None |
| Result 型 | Result<T, E>: Ok(v) または Err(e) |
| Result を返す | fn read() -> Result<String, Error> { ... } |
| ? で伝播 | let data = read()?; |
| unwrap (None/Err で panic) | opt.unwrap() |
| デフォルト値 | opt.unwrap_or(0) |
| 値を map | opt.map(|v| v + 1) |
| 両方のアームを処理 | match res { Ok(v) => ..., Err(e) => ... } |
| Option を Result に変換 | opt.ok_or("missing")? |
よく使うコレクション (Vec / HashMap)
Vec は拡張可能な配列で、HashMap はキーと値のストアです。
| 操作 | 構文 |
|---|---|
| ベクタを作成 | let mut v: Vec<i32> = Vec::new(); |
| ベクタリテラル | let v = vec![1, 2, 3]; |
| push / pop | v.push(4);, v.pop(); |
| インデックスアクセス | v[0] |
| 安全なアクセス | v.get(0) は Option<&T> を返す |
| 反復 | for x in &v { ... } |
| 長さ | v.len() |
| マップを作成 | let mut m: HashMap<String, i32> = HashMap::new(); |
| 挿入 / 取得 | m.insert(k, v);, m.get(&k) |
| Entry API | *m.entry(k).or_insert(0) += 1; |
最もよく使う Rust の構文を 1 ページにまとめました。この Rust チートシートは、言語の中核のクイックリファレンスです。変数と可変性、所有権と借用、構造体と列挙型、パターンマッチング、トレイトとジェネリクス、そして Rust のエラー処理を支える Result と Option 型を収録しています。
ここに載っているものはすべて標準の Rust で、最近の安定版ツールチェーンでコンパイルできます。必要なものをコピーするか、Rust プレイグラウンドですべてのスニペットをその場で試してみてください。cargo のインストールは不要です。
Rust チートシート よくある質問
この Rust チートシートは無料ですか?
はい。この Rust チートシートは完全に無料で、登録も不要です。ブックマークしておけば、match のパターンやトレイト境界、コレクションのメソッドを調べたいときにいつでも戻ってこられます。
Rust の所有権と借用とは何ですか?
所有権は Rust のメモリモデルです。すべての値にはちょうど 1 つの所有者があり、その所有者がスコープを抜けると値は解放されます。借用を使うと、参照を使って所有権を取らずに値にアクセスできます。不変の借用には
&x、可変の借用には &mut x を使います。コンパイラは 1 つのルールを強制します。同時に複数の不変借用、またはちょうど 1 つの可変借用を持てます。これによりコンパイル時にデータ競合を防ぎます。Rust の Result と Option の違いは何ですか?
Option<T> は値が不在かもしれないことを表し、Some(v) か None のいずれかです。報告すべきエラーはなく、ただ値が欠けているだけのときに使います。Result<T, E> は失敗し得る操作を表し、Ok(v) か Err(e) のいずれかで、何かうまくいかなかったときにエラー値を運びます。「あるかもしれない」には Option、「これは失敗し得る」には Result を使いましょう。? 演算子はどちらも伝播します。Rust をオンラインで練習できますか?
はい。Rust プレイグラウンドを開けば、このチートシートのどのスニペットも、ブラウザ上でコンパイルして実行できます。cargo やツールチェーンのインストールは不要です。体系的に学びたいときは、Coddy の無料インタラクティブ Rust コースが、変数と所有権からトレイト、エラー処理まで段階的に導いてくれます。
このチートシートは初心者に向いていますか?
はい。最もよく使うトピック (変数、制御フロー、関数) から高度なもの (トレイト、ジェネリクス、エラー処理) へと並べてあるので、初日から上のセクションを使い、所有権やその他には慣れながら進めます。
関連リソース
他のチートシート
