Rust - 分类 - 星辰逐梦

Rust CLI 工具与序列化（clap + Serde）

ixiaoqiang0011@gmail.com (星辰逐梦) — Tue, 31 Mar 2026 00:00:00 +0000

学 Rust，迟早要写命令行工具。clap 负责解析参数，Serde 负责数据序列化——这两样几乎出现在每个真实项目里。

clap：解析命令行参数

Cargo.toml：

        
[dependencies]
clap = { version = "4", features = ["derive"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

用 derive 宏定义参数，写起来像普通结构体：

Rust Axum Web 开发

ixiaoqiang0011@gmail.com (星辰逐梦) — Mon, 23 Mar 2026 00:00:00 +0000

Axum 是 Tokio 团队出品的现代 Web 框架，基于异步，API 简洁。它和前面学的 trait、async、所有权无缝衔接，是练手最佳选择。

异步函数

async fn 返回一个「未来（Future）」，它本身不执行，需要运行时去驱动：

Rust 多线程与 Channel

ixiaoqiang0011@gmail.com (星辰逐梦) — Sun, 08 Mar 2026 00:00:00 +0000

Rust 的并发哲学是「无畏并发（fearless concurrency）」：编译器在编译期就帮你避开数据竞争。线程用 std::thread，线程间通信靠 Channel。

Rust 模块系统与 Cargo

ixiaoqiang0011@gmail.com (星辰逐梦) — Sun, 01 Mar 2026 00:00:00 +0000

随着代码变多，你需要模块来组织，用 Cargo 来管理依赖和构建。这是写真实项目的基础。

模块 mod

        
        
        
    
mod math {
    pub fn add(a: i32, b: i32) -> i32 { a + b } // pub 才对外可见
    fn secret() -> i32 { 42 }
}

fn main() {
    println!("{}", math::add(2, 3)); // 5
    // math::secret(); // ❌ 私有，无法访问
}

pub 控制可见性，默认模块内私有。可多层嵌套、可用 use 引入：

Rust 闭包与迭代器

ixiaoqiang0011@gmail.com (星辰逐梦) — Sat, 21 Feb 2026 00:00:00 +0000

闭包是「能捕获环境的匿名函数」，迭代器让你用链式调用优雅地处理集合。两者是 Rust 函数式风格的两张王牌。

闭包

        
fn main() {
    let factor = 3;
    let mul = |x: i32| x * factor; // 捕获了 factor
    println!("{}", mul(4)); // 12
}

闭包语法 |参数| 体，常能靠类型推导省去标注。它能捕获周围变量（这是和普通函数最大的不同）。

Rust 生命周期

ixiaoqiang0011@gmail.com (星辰逐梦) — Sat, 14 Feb 2026 00:00:00 +0000

生命周期（Lifetime）标注告诉编译器：引用活多久，从而确保你不会拿一个已经失效的引用。多数时候编译器能自动推导，只有含糊时才需要手写。

为什么需要它

        
fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}

编译器不知道返回的引用来自 x 还是 y，也就没法保证它比两者都长寿——会报错，需要显式标注。

Rust 泛型与 Trait

ixiaoqiang0011@gmail.com (星辰逐梦) — Sat, 07 Feb 2026 00:00:00 +0000

泛型让你写「一套代码适配多种类型」，Trait 则定义「类型能做什么」。两者结合，是 Rust 抽象能力的核心。

定义结构体与方法

        
        
        
    
struct User {
    name: String,
    age: u32,
}

impl User {
    // 关联函数（类似构造器）
    fn new(name: &str, age: u32) -> User {
        User { name: name.to_string(), age }
    }
    // 方法：第一个参数是 self
    fn greet(&self) -> String {
        format!("你好，我是 {}，{} 岁", self.name, self.age)
    }
}

fn main() {
    let u = User::new("小明", 18);
    println!("{}", u.greet());
}

错误处理：Result

可能失败的函数返回 Result：

Rust 基础类型与模式匹配

ixiaoqiang0011@gmail.com (星辰逐梦) — Fri, 23 Jan 2026 00:00:00 +0000

Rust 的类型系统很务实：标量类型够用，复合类型灵活，而 enum + match 是它表达「多种可能」的利器。

标量类型

        
let i: i32 = -10;        // 有符号整数
let u: u8 = 255;         // 无符号（0~255）
let f: f64 = 3.14;       // 浮点
let b: bool = true;      // 布尔
let c: char = 'R';       // 字符（Unicode，4 字节）

复合类型

        
let tup: (i32, f64, char) = (500, 6.4, 'z'); // 元组
let (a, _b, c) = tup;                         // 解构
let arr = [1, 2, 3, 4, 5];                    // 数组（定长）
let first = arr[0];

枚举 enum

枚举把「一组相关的可能值」打包：