Rust 速查表

所有工具

免费

可搜索、可打印的 Rust 参考——所有权和借用、trait、模式匹配、Option 和 Result、迭代器和 Cargo。免费。

Basics

let 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

let 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

struct 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

match 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

let 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

trait 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

let 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

v.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

fn 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

let 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

let 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

cargo 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

没有条目匹配“:q”。

关于 Rust 速查表

这份 Rust 速查表按概念在一个可搜索的页面上梳理了整个语言：基础知识、所有权、借用和生命周期、结构体、枚举和 impl 块、模式匹配、Option 和 Result、Trait 和泛型、集合、迭代器和闭包、错误处理、智能指针和内部可变性、并发和异步，以及 Cargo 命令行。

所有权是人们反复查阅的 Rust 部分，因此它与生命周期、借用规则、Box、Rc、Arc 和 RefCell 各有专门章节——同时也涵盖了 match 分支、? 运算符、迭代器适配器和 derive trait 等日常语法。

与本系列的其他速查表一样，它免费且在客户端运行：使用搜索框实时过滤行，通过固定目录在章节间跳转，点击即可复制任何代码片段，还可以打印页面作为桌边参考。

如何使用 Rust 速查表

打开速查表，浏览各章节，从“基础知识”和“所有权和借用”到“Cargo 命令行”。
搜索关键词如 lifetime、match 或 Arc 以实时过滤。
需要地道的错误处理写法时跳转到“Option 和 Result”或“错误处理”。
点击代码片段或其复制图标，将 Rust 代码复制到剪贴板。
使用打印功能获取完整 Rust 参考的纸质版。

常见问题

十二个章节：基础知识、所有权、借用和生命周期、结构体、枚举和 impl、模式匹配、Option 和 Result、Trait 和泛型、集合、迭代器和闭包、错误处理、智能指针和内部可变性、并发和异步，以及 Cargo 命令行。

是的。专门的章节展示了移动、借用、可变借用、借用检查器规则和生命周期标注，每一行都有简短说明。

涵盖——Option 和 Result 的组合子、? 运算符、自定义错误类型、From 转换以及常见的 crate 模式，都以可复制的代码片段呈现。

可以。点击任意行的代码或其复制图标，即可立即复制。

是的，完全免费，在浏览器中运行，无需登录。

Rust 速查表

Basics

Ownership, borrowing & lifetimes

Structs, enums & impl

Pattern matching

Option & Result

Traits & generics

Collections

Iterators & closures

Error handling

Smart pointers & interior mutability

Concurrency & async

Cargo CLI

关于 Rust 速查表

如何使用 Rust 速查表

常见问题

Rust 速查表涵盖哪些内容？

它解释所有权和借用吗？

它涵盖错误处理吗？

可以一键复制代码片段吗？

Rust 参考是免费的吗？

相关工具

热门搜索

嵌入此工具