Bảng tra cứu nhanh Rust
Tài liệu tra cứu Rust có thể tìm kiếm và in: ownership và borrowing, traits, pattern matching, Option và Result, iterators và Cargo. Miễn phí.
Basics
10let x = 5;
Immutable binding (default)
let mut count = 0; count += 1;
Mutable binding
let x = "5"; let x: i32 = x.parse()?;
Shadowing (new type allowed)
i32, u64, f64, bool, char, usize
Core scalar types
let t = (1, "a"); t.0
Tuple + field access
let a = [0u8; 16];
Fixed array of 16 zeros
const MAX_USERS: u32 = 100;
Compile-time constant
let n = big as u8;
Explicit numeric cast
let s: String; let sl: &str;
Owned string vs string slice
println!("{name} has {count}");
Inline variable interpolation
Ownership, borrowing & lifetimes
10let b = a; // a is moved
Assignment moves non-Copy types
let b = a.clone();
Deep copy keeps both usable
fn read(s: &String) / read(&s)
Shared borrow (many allowed)
fn edit(s: &mut String) / edit(&mut s)
Exclusive borrow (only one)
// no &mut while & borrows live
The core borrow rule
fn greet(name: &str)
Prefer &str params over &String
i32, bool, char, &T are Copy
Copy types never move
fn first<'a>(a: &'a str, b: &str) -> &'a str
Tie output to an input lifetime
struct View<'a> { text: &'a str }
Struct holding a reference
let s: &'static str = "literal";
Lives for the whole program
Structs, enums & impl
10struct User { name: String, age: u32 }
Struct definition
let u = User { name, age: 30 };
Literal + field-init shorthand
let u2 = User { age: 31, ..u };
Struct update syntax
struct Meters(f64);
Tuple struct (newtype idiom)
impl User { fn new(name: String) -> Self { ... } }
Associated constructor
fn label(&self) -> String
Method borrowing self
fn rename(&mut self, n: String)
Method mutating self
enum Shape { Circle(f64), Rect { w: f64, h: f64 } }
Enum with data per variant
#[derive(Debug, Clone, PartialEq)]
Auto-implement common traits
let cfg = Config::default();
Default trait construction
Pattern matching
10match n { 0 => "zero", _ => "other" }
Exhaustive match expression
match shape { Shape::Circle(r) => ... }
Destructure enum variants
match n { 1..=5 => "low", _ => "high" }
Range patterns
match p { Point { x, y: 0 } => ... }
Destructure struct fields
Some(n) if n > 10 => "big"
Match guard
id @ 1..=9 => use(id)
Bind while matching (@)
if let Some(v) = opt { use(v); }
Match a single pattern
let Some(v) = opt else { return; };
let-else early exit
while let Some(x) = stack.pop() { ... }
Loop while a pattern holds
matches!(status, Status::Active)
Boolean pattern test macro
Option & Result
12let opt: Option<i32> = Some(5);
Maybe-a-value type
let res: Result<T, E> = Ok(v);
Success-or-error type
let v = load()?;
? propagates None / Err up
opt.unwrap_or(0)
Value or a default
opt.unwrap_or_else(|| compute())
Lazy default
opt.unwrap_or_default()
Value or Default::default()
opt.map(|v| v * 2)
Transform if present
opt.and_then(|v| v.checked_mul(2))
Chain fallible steps (flatMap)
opt.ok_or(MyError::Missing)?
Option → Result
res.map_err(|e| AppError::Io(e))
Convert the error type
opt.is_some(); res.is_err();
Cheap state checks
let v = opt.take();
Move out, leave None behind
Traits & generics
11trait Greet { fn hello(&self) -> String; }
Trait: shared behavior
trait Greet { fn wave(&self) { ... } }
Default method body
impl Greet for User { ... }
Implement for a type
fn welcome<T: Greet>(x: &T)
Generic with a trait bound
fn f<T>(x: T) where T: Greet + Clone
where clause for many bounds
fn welcome(x: &impl Greet)
impl Trait argument sugar
fn make() -> impl Iterator<Item = u32>
Opaque return type
let objs: Vec<Box<dyn Greet>> = ...;
Trait objects (dynamic dispatch)
impl From<u32> for Meters { ... }
From gives you Into for free
let m: Meters = 5u32.into();
Convert via Into
impl fmt::Display for User { ... }
Custom {} formatting
Collections
12let mut v = vec![1, 2, 3];
Vec literal macro
v.push(4); v.pop();
Append / remove last
v.get(0) // Option<&T>
Safe indexing (v[9] panics)
for x in &v { ... }
Iterate by reference
v.sort(); v.sort_by_key(|u| u.age);
In-place sorting
v.retain(|x| *x > 0);
Keep matching elements
let mut m = HashMap::new(); m.insert(k, v);
Hash map basics
*counts.entry(word).or_insert(0) += 1;
Entry API counter idiom
m.contains_key(&k); m.get(&k);
Lookups return Option
s.push_str("more"); format!("{a}{b}")
Grow / build strings
s.chars().rev().collect::<String>()
Char-wise string processing
names.join(", ")
Join a Vec<String>
Iterators & closures
14v.iter().map(|x| x * 2).collect::<Vec<_>>()
Transform and materialize
.filter(|x| **x > 0)
Keep matching elements
.filter_map(|s| s.parse().ok())
Filter + map in one pass
.sum::<i32>(); .count(); .max()
Common consumers
.fold(0, |acc, x| acc + x)
General reduction
.enumerate()
Pairs of (index, item)
.zip(other.iter())
Walk two iterators together
.take(5); .skip(2); .rev()
Slice and reverse lazily
.flat_map(|l| l.split(' '))
Map then flatten
.any(|x| x < 0); .all(|x| x > 0)
Short-circuit predicates
.find(|u| u.id == id); .position(...)
First match / its index
iter() &T; iter_mut() &mut T; into_iter() T
The three iteration modes
let add = move |x| x + base;
move closure takes ownership
.collect::<HashMap<_, _>>()
Collect pairs into a map
Error handling
11fn run() -> Result<(), Box<dyn Error>>
Quick catch-all error type
fn main() -> anyhow::Result<()>
anyhow for applications
file.read().context("reading config")?;
anyhow: attach context
anyhow::bail!("invalid input: {x}");
Early return with an error
#[derive(thiserror::Error, Debug)]
thiserror for libraries
#[error("user {0} not found")] NotFound(u64),
Display message per variant
#[error(transparent)] Io(#[from] std::io::Error),
Auto-From wrapped errors
enum AppError { Db(String), Timeout }
Custom error enum
let n = do_it()?; // Err auto-converts
? uses From between error types
opt.expect("config must be loaded")
unwrap/expect: tests only
eprintln!("error: {e:#}");
Print the full error chain
Smart pointers & interior mutability
11let b = Box::new(BigStruct::new());
Heap allocation, sole owner
enum List { Node(i32, Box<List>), Nil }
Box enables recursive types
let a = Rc::new(data); let b = Rc::clone(&a);
Shared owner, single thread
let a = Arc::new(data);
Shared owner across threads
let c = RefCell::new(0); *c.borrow_mut() += 1;
Runtime-checked mutation
Rc<RefCell<T>>
Shared + mutable (one thread)
let m = Mutex::new(0); *m.lock().unwrap() += 1;
Thread-safe mutation
Arc<Mutex<T>>
Shared + mutable across threads
let l = RwLock::new(map); l.read(); l.write();
Many readers or one writer
Cell::new(5).set(6);
Copy-type interior mutability
let w = Rc::downgrade(&a); w.upgrade()
Weak breaks reference cycles
Concurrency & async
13let h = thread::spawn(|| work()); h.join()
Spawn and join a thread
thread::spawn(move || use(data))
move data into the thread
thread::scope(|s| { s.spawn(|| ...); })
Borrow locals in threads
let (tx, rx) = mpsc::channel();
Multi-producer channel
tx.send(job)?; let job = rx.recv()?;
Send / blocking receive
let n = Arc::new(Mutex::new(0));
Shared counter pattern
#[tokio::main] async fn main() { ... }
Async runtime entry point
async fn fetch() -> Result<Data>
Async function
let data = fetch().await?;
Await a future
let h = tokio::spawn(fetch()); h.await??;
Spawn an async task
let (a, b) = tokio::join!(f1(), f2());
Run futures concurrently
tokio::time::sleep(Duration::from_secs(1)).await;
Non-blocking sleep
tokio::select! { r = f1() => ..., _ = f2() => ... }
First future to finish wins
Cargo CLI
12cargo new my-app
Create a binary project
cargo add serde --features derive
Add a dependency
cargo run
Build and run (debug)
cargo build --release
Optimized build
cargo check
Type-check fast, no binary
cargo test
Run tests (+ doc tests)
cargo clippy -- -D warnings
Lints, warnings as errors
cargo fmt
Format the whole project
cargo doc --open
Build and browse the docs
cargo update
Refresh Cargo.lock versions
cargo install ripgrep
Install a binary crate
cargo tree
Show the dependency graph
Không có mục nào khớp với “:q”.
Giới thiệu về Bảng tra cứu nhanh Rust
Bảng tra cứu Rust này vạch ra ngôn ngữ theo khái niệm trên một trang có thể tìm kiếm: cơ bản, ownership, borrowing và lifetime, struct, enum và khối impl, pattern matching, Option và Result, trait và generics, collection, iterator và closure, xử lý lỗi, smart pointer và interior mutability, đồng thời và async, và dòng lệnh Cargo.
Ownership là phần của Rust mà người ta hay quay lại tra cứu, nên nó có phần riêng cạnh lifetime, quy tắc borrowing, Box, Rc, Arc và RefCell: cùng với cú pháp hằng ngày như nhánh match, toán tử ?, iterator adapter và derive trait.
Như mọi bảng tra cứu trong nhóm này, nó miễn phí và chạy phía máy khách: lọc hàng trực tiếp bằng ô tìm kiếm, nhảy giữa các phần bằng mục lục cố định, sao chép bất kỳ đoạn mã nào chỉ với một cú nhấp và in trang làm tài liệu tham khảo tại bàn làm việc.
Cách sử dụng Bảng tra cứu nhanh Rust
- Mở bảng và xem các phần, từ Cơ bản và Ownership & borrowing đến Cargo CLI.
- Tìm một từ khóa như lifetime, match hoặc Arc để lọc bảng trực tiếp.
- Nhảy tới Option & Result hoặc Xử lý lỗi khi bạn cần cách thất bại đúng chuẩn.
- Nhấp vào một đoạn mã hoặc biểu tượng sao chép của nó để sao chép mã Rust vào khay nhớ tạm.
- Dùng In để có bản giấy của toàn bộ tài liệu tham khảo Rust.
Câu hỏi thường gặp
Mười hai phần: cơ bản, ownership, borrowing và lifetime, struct, enum và impl, pattern matching, Option và Result, trait và generics, collection, iterator và closure, xử lý lỗi, smart pointer và interior mutability, đồng thời và async, và Cargo CLI.
Có. Một phần riêng trình bày move, borrow, mutable borrow, quy tắc của borrow checker và chú thích lifetime kèm lời giải thích ngắn ở mỗi hàng.
Có: các combinator của Option và Result, toán tử ?, kiểu lỗi tùy chỉnh, chuyển đổi From và các mẫu crate phổ biến đều xuất hiện dưới dạng đoạn mã sẵn để sao chép.
Có. Nhấp vào mã trên bất kỳ hàng nào hoặc biểu tượng sao chép của nó và nó được sao chép ngay lập tức.
Có, hoàn toàn miễn phí và chạy trong trình duyệt của bạn mà không cần đăng nhập.
Tìm kiếm phổ biến
rust cheat sheet
tài liệu tham khảo cú pháp rust
rust ownership và borrowing
giải thích rust lifetimes
option và result trong rust
rust traits và generics
các lệnh cargo
Cần trợ giúp?
Gặp sự cố với công cụ này? Hãy cho đội ngũ của chúng tôi biết.