Cheat sheet Rust
Cập nhật lần cuối
Hello World và cấu trúc chương trình
Chương trình Rust bắt đầu từ fn main; câu lệnh kết thúc bằng dấu chấm phẩy.
| Thao tác | Cú pháp |
|---|---|
| Điểm bắt đầu chương trình | fn main() { ... } |
| In một dòng | println!("Hello, World!"); |
| In kèm giá trị | println!("{} is {}", name, age); |
| In dạng debug | println!("{:?}", value); |
| Chú thích một dòng | // comment |
| Dùng một item từ module | use std::collections::HashMap; |
| Build và chạy | cargo run |
| Build bản release | cargo build --release |
Biến và kiểu dữ liệu (let / mut)
Binding mặc định là bất biến; thêm mut để cho phép gán lại.
| Thao tác | Cú pháp |
|---|---|
| Binding bất biến | let x = 5; |
| Binding khả biến | let mut count = 0; |
| Khai báo kiểu tường minh | let age: u32 = 30; |
| Hằng số | const MAX: u32 = 100; |
| Che biến (shadowing) | let x = x + 1; |
| Các kiểu số nguyên | i32, u32, i64, usize |
| Các kiểu vô hướng khác | f64, bool, char |
| Tuple | let pair: (i32, &str) = (1, "a"); |
| Ép kiểu | let f = x as f64; |
Luồng điều khiển
if là một biểu thức, và Rust có ba dạng vòng lặp.
| Thao tác | Cú pháp |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| if dùng như biểu thức | let y = if x > 0 { 1 } else { -1 }; |
| Vòng lặp vô hạn | loop { ... } |
| Vòng lặp trả về giá trị | let v = loop { break 5; }; |
| Vòng lặp while | while x < 100 { ... } |
| Vòng lặp for qua một khoảng | for i in 0..10 { ... } |
| Vòng lặp for qua một collection | for item in &items { ... } |
| break / continue | break;, continue; |
Hàm
Biểu thức cuối cùng (không có dấu chấm phẩy) là giá trị trả về.
| Thao tác | Cú pháp |
|---|---|
| Hàm cơ bản | fn add(a: i32, b: i32) -> i32 { a + b } |
| Trả về tường minh | fn f() -> i32 { return 5; } |
| Không có giá trị trả về | fn log(msg: &str) { ... } |
| Nhận một tham chiếu | fn len(s: &String) -> usize { s.len() } |
| Closure | let add = |a, b| a + b; |
| Closure có khai báo kiểu | let sq = |x: i32| -> i32 { x * x }; |
| Hàm làm đối số | fn apply(f: impl Fn(i32) -> i32) { ... } |
Ownership và borrowing
Mỗi giá trị có một chủ sở hữu; tham chiếu mượn giá trị mà không lấy quyền sở hữu.
| Thao tác | Cú pháp |
|---|---|
| Move (chuyển quyền sở hữu) | let b = a; (a không còn hợp lệ) |
| Clone (sao chép sâu) | let b = a.clone(); |
| Borrow bất biến | let r = &x; |
| Borrow khả biến | let r = &mut x; |
| Borrow trong một hàm | fn read(s: &String) { ... } |
| Giải tham chiếu | *r |
| Quy tắc borrowing | Nhiều & HOẶC một &mut tại một thời điểm, không được cả hai |
| Slice (mượn một khoảng) | let part = &arr[1..3]; |
Struct và enum
Struct gom các dữ liệu liên quan; enum mô tả một giá trị thuộc một trong nhiều biến thể.
| Thao tác | Cú pháp |
|---|---|
| Định nghĩa struct | struct Point { x: i32, y: i32 } |
| Tạo một instance | let p = Point { x: 1, y: 2 }; |
| Truy cập trường | p.x |
| Struct dạng tuple | struct Pair(i32, i32); |
| Phương thức (khối impl) | impl Point { fn dist(&self) -> f64 { ... } } |
| Hàm liên kết (associated function) | impl Point { fn new() -> Self { ... } } |
| Định nghĩa enum | enum Shape { Circle(f64), Rect(f64, f64) } |
| Enum có trường đặt tên | enum Msg { Move { x: i32, y: i32 } } |
| Derive trait | #[derive(Debug, Clone)] |
Pattern matching (match)
match so sánh một giá trị với các mẫu và phải bao quát mọi trường hợp.
| Thao tác | Cú pháp |
|---|---|
| Match theo giá trị | match x { 1 => "one", _ => "other" } |
| Match một enum | match shape { Shape::Circle(r) => ... } |
| Match một khoảng | match n { 1..=5 => ..., _ => ... } |
| Gắn biến kèm guard | match x { n if n > 0 => ... } |
| Match một tuple | match point { (0, y) => ..., (x, _) => ... } |
| if let (một mẫu duy nhất) | if let Some(v) = opt { ... } |
| while let | while let Some(v) = stack.pop() { ... } |
| Phân rã một struct | let Point { x, y } = p; |
Trait và generic
Trait định nghĩa hành vi dùng chung; generic giúp code chạy được với nhiều kiểu.
| Thao tác | Cú pháp |
|---|---|
| Định nghĩa trait | trait Area { fn area(&self) -> f64; } |
| Cài đặt trait | impl Area for Circle { fn area(&self) -> f64 { ... } } |
| Phương thức mặc định | trait Greet { fn hi(&self) { ... } } |
| Hàm generic | fn largest<T: PartialOrd>(list: &[T]) -> &T { ... } |
| Struct generic | struct Wrapper<T> { value: T } |
| Trait bound (where) | fn f<T>(x: T) where T: Display { ... } |
| Đối số impl Trait | fn print(item: impl Display) { ... } |
| Trait object | let shapes: Vec<Box<dyn Area>> = ...; |
Xử lý lỗi (Result / Option)
Rust dùng Option cho giá trị có thể vắng mặt và Result cho lỗi có thể phục hồi.
| Thao tác | Cú pháp |
|---|---|
| Giá trị tùy chọn | Option<T>: Some(v) hoặc None |
| Kiểu Result | Result<T, E>: Ok(v) hoặc Err(e) |
| Trả về một Result | fn read() -> Result<String, Error> { ... } |
| Lan truyền lỗi bằng ? | let data = read()?; |
| Unwrap (panic khi gặp None/Err) | opt.unwrap() |
| Giá trị mặc định | opt.unwrap_or(0) |
| Biến đổi giá trị bằng map | opt.map(|v| v + 1) |
| Xử lý cả hai nhánh | match res { Ok(v) => ..., Err(e) => ... } |
| Chuyển Option thành Result | opt.ok_or("missing")? |
Collection thường dùng (Vec / HashMap)
Vec là mảng có thể mở rộng; HashMap lưu cặp khóa và giá trị.
| Thao tác | Cú pháp |
|---|---|
| Tạo một vector | let mut v: Vec<i32> = Vec::new(); |
| Tạo vector với giá trị sẵn có | let v = vec![1, 2, 3]; |
| Thêm vào cuối / lấy ra cuối | v.push(4);, v.pop(); |
| Truy cập theo chỉ số | v[0] |
| Truy cập an toàn | v.get(0) trả về Option<&T> |
| Duyệt qua | for x in &v { ... } |
| Độ dài | v.len() |
| Tạo một map | let mut m: HashMap<String, i32> = HashMap::new(); |
| Thêm / lấy | m.insert(k, v);, m.get(&k) |
| Entry API | *m.entry(k).or_insert(0) += 1; |
Cú pháp Rust bạn dùng nhiều nhất, gom trong một trang. Cheat sheet Rust này là bảng tra cứu nhanh cho phần cốt lõi của ngôn ngữ: biến và tính khả biến (mutability), ownership và borrowing, struct và enum, pattern matching, trait và generic, cùng hai kiểu Result và Option làm nên cách Rust xử lý lỗi.
Mọi thứ ở đây đều là Rust chuẩn, biên dịch được trên một bản toolchain stable gần đây. Sao chép phần bạn cần, hoặc chạy thử từng đoạn code ngay trong playground Rust, không cần cài cargo.
Câu hỏi thường gặp về cheat sheet Rust
Cheat sheet Rust này có miễn phí không?
Có. Cheat sheet Rust này hoàn toàn miễn phí, không cần đăng ký. Lưu trang lại và quay lại bất cứ khi nào bạn cần tra một mẫu match, trait bound hay phương thức của collection.
Ownership và borrowing trong Rust là gì?
&x để mượn bất biến hoặc &mut x để mượn khả biến. Trình biên dịch áp một quy tắc: tại một thời điểm, bạn có thể có nhiều borrow bất biến hoặc đúng một borrow khả biến, nhờ vậy data race bị chặn ngay lúc biên dịch.Result và Option trong Rust khác nhau thế nào?
Option<T> đại diện cho một giá trị có thể vắng mặt: nó là Some(v) hoặc None, và bạn dùng nó khi không có lỗi gì để báo, chỉ là thiếu giá trị. Result<T, E> đại diện cho một thao tác có thể thất bại: nó là Ok(v) hoặc Err(e), mang theo giá trị lỗi khi có sự cố. Dùng Option cho trường hợp "có thể có" và Result cho trường hợp "có thể lỗi"; toán tử ? lan truyền được cả hai.Có thể luyện tập Rust online không?
Có. Mở playground Rust để biên dịch và chạy bất kỳ đoạn code nào trong cheat sheet này ngay trên trình duyệt, không cần cài cargo hay toolchain. Khi muốn học có lộ trình, khóa học Rust tương tác miễn phí của Coddy dẫn bạn từng bước từ biến và ownership đến trait và xử lý lỗi.
Cheat sheet này có phù hợp cho người mới bắt đầu không?
Có. Nội dung đi từ các chủ đề thông dụng nhất (biến, luồng điều khiển, hàm) đến các chủ đề nâng cao (trait, generic, xử lý lỗi), nên ngay ngày đầu bạn đã dùng được các phần trên cùng, rồi dần làm quen với ownership và phần còn lại.
Tài nguyên liên quan
Thêm cheat sheet
