Rust 进阶

这部分聚焦 Rust 的核心能力：所有权、生命周期、trait、泛型、并发与异步。

一、所有权（Ownership）

Rust 通过一组固定规则保证内存安全：每个值只有一个所有者；同一时刻所有权不会被多个变量同时持有；当所有者离开作用域时，资源会被自动释放。

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // 所有权移动，s1 不再可用
    println!("{s2}");
}

二、借用与引用（Borrowing）

fn len(s: &String) -> usize {
    s.len()
}

fn main() {
    let s = String::from("rust");
    println!("{}", len(&s)); // 借用，不转移所有权
}

&T 是不可变借用，可以同时存在多个；&mut T 是可变借用，同一时刻只能存在一个；可变借用与不可变借用不能在同一时间重叠出现。

三、生命周期（Lifetime）

生命周期用于描述引用的有效期关系，避免悬垂引用。

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

fn main() {
    let a = String::from("abcd");
    let b = "xyz";
    println!("{}", longest(&a, b));
}

四、泛型与 Trait

1) 泛型函数

generic

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut max = list[0];
    for &item in list {
        if item > max {
            max = item;
        }
    }
    max
}

2) Trait 与实现

trait

trait Summary {
    fn summary(&self) -> String;
}

struct Post {
    title: String,
}

impl Summary for Post {
    fn summary(&self) -> String {
        format!("post: {}", self.title)
    }
}

五、模式匹配与 Option

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        Some(v) => Some(v + 1),
        None => None,
    }
}

Option<T> 强制你显式处理“有值/无值”，避免空指针风格错误。

六、并发与异步

1) 线程并发

thread

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("from thread");
    });
    handle.join().unwrap();
}

2) async/await（以 Tokio 为例）

async/await

async fn fetch_data() -> String {
    "ok".to_string()
}

#[tokio::main]
async fn main() {
    let data = fetch_data().await;
    println!("{data}");
}

七、进阶学习路线建议

比较稳妥的顺序是：先强化所有权与借用检查器报错阅读能力，再熟练 Result、Option 和 ? 运算符，然后进入 trait 抽象与泛型约束设计。完成这些后再系统学习异步生态（Tokio、Axum、SQLx），最后把 clippy 和 rustfmt 纳入日常工程规范。